@astrale-os/sdk 0.5.0-beta.43 → 0.5.0-beta.44

package/dist/platform/schema/index.d.ts

@@ -1,4 +1,4 @@
-/** Canonical Schema authoring, compilation, loading, and resolved Domain surface. */
+import { KernelSchema as CoreKernelSchema } from '@astrale-os/kernel-core/schema';
 export * from '@astrale-os/kernel-dsl/v1';
 export { patterns } from '@astrale-os/kernel-dsl/v1/addressing';
 export type { CallablePolicyBuilder, CallablePolicyContext, CallableProjection, AuthoredMethodProjection, AuthoredPropertyProjection, ClassIdentityProjection, ClassOwnerProjection, CoreEdge, CoreEndpoint, CoreNode, DefinedSchema, DirectedEdgeClass, ClassReferenceProjection, ClassProjection, FunctionProjection, EdgeClass, Function, Method, MethodProjection, Lazy, NodeClass, Policy, Property, PropertyProjection, ResolvedDomainOfInput, View, } from '@astrale-os/kernel-dsl/v1/builder';
@@ -6,5 +6,11 @@ export type { Array, Object, Value } from '@astrale-os/kernel-dsl/value';
 export type { ClassKind, DirectedEdgeContract, EdgeClassPolicies, NodeClassDefinition, PolicyCheckObject, PropertyFacet, UndirectedEdgeContract, } from '@astrale-os/kernel-dsl/v1/language';
 export type { DomainSchema } from '@astrale-os/kernel-dsl/v1/schema';
 /** Kernel-owned Schema values used by authored product Schemas and graph operations. */
-export { AuthorityOperationOrder, AuthorityOperations, AuthorityRelations, K, KernelRootFunctions, KernelSchema, OperationCore, operationOf, } from '@astrale-os/kernel-core/schema';
+export { AuthorityOperationOrder, AuthorityOperations, AuthorityRelations, K, KernelRootFunctions, OperationCore, operationOf, } from '@astrale-os/kernel-core/schema';
 export type { AuthorityOperation, AuthorityRelation, Kernel } from '@astrale-os/kernel-core/schema';
+/**
+ * Re-admit the Kernel Schema into the SDK's DSL instance. Package-manager trees may retain a
+ * different DSL instance below Kernel Core; acceptance context is intentionally process-local.
+ */
+export declare const KernelSchema: typeof CoreKernelSchema;
+export type KernelSchema = typeof CoreKernelSchema;

package/dist/platform/schema/index.js

@@ -1,5 +1,12 @@
+import { KernelSchema as CoreKernelSchema } from '@astrale-os/kernel-core/schema';
 /** Canonical Schema authoring, compilation, loading, and resolved Domain surface. */
+import { schema as language } from '@astrale-os/kernel-dsl/v1';
 export * from '@astrale-os/kernel-dsl/v1';
 export { patterns } from '@astrale-os/kernel-dsl/v1/addressing';
 /** Kernel-owned Schema values used by authored product Schemas and graph operations. */
-export { AuthorityOperationOrder, AuthorityOperations, AuthorityRelations, K, KernelRootFunctions, KernelSchema, OperationCore, operationOf, } from '@astrale-os/kernel-core/schema';
+export { AuthorityOperationOrder, AuthorityOperations, AuthorityRelations, K, KernelRootFunctions, OperationCore, operationOf, } from '@astrale-os/kernel-core/schema';
+/**
+ * Re-admit the Kernel Schema into the SDK's DSL instance. Package-manager trees may retain a
+ * different DSL instance below Kernel Core; acceptance context is intentionally process-local.
+ */
+export const KernelSchema = language.accept(CoreKernelSchema);

package/dist/tooling/packaging/admission.js

@@ -66,7 +66,7 @@ function moduleSpecifier(node) {
         return node.argument.literal.text;
     }
     if (ts.isCallExpression(node) &&
-        node.arguments.length === 1 &&
+        node.arguments.length > 0 &&
         ts.isStringLiteral(node.arguments[0]) &&
         (node.expression.kind === ts.SyntaxKind.ImportKeyword ||
             (ts.isIdentifier(node.expression) && node.expression.text === 'require'))) {

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

@@ -1,8 +1,10 @@
 export interface DomainPackageCompilation {
     readonly root: string;
+    readonly typeClosure: readonly DomainPackageTypeClosure[];
 }
-export interface DomainPackageCompilationInput {
-    readonly declarations: readonly string[];
+export interface DomainPackageTypeClosure {
+    readonly source: string;
+    readonly target: string;
 }
-/** Compile one Domain's public runtime package from its dedicated package config. */
-export declare function compileDomainPackage(projectDir: string, input: DomainPackageCompilationInput): DomainPackageCompilation;
+/** Compile one Domain's admitted Schema contract with SDK-owned emit policy. */
+export declare function compileDomainPackage(projectDir: string): DomainPackageCompilation;

package/dist/tooling/packaging/compile.js

@@ -1,70 +1,55 @@
 import { spawnSync } from 'node:child_process';
-import { existsSync, mkdtempSync, readFileSync, rmSync, writeFileSync } from 'node:fs';
+import { existsSync, mkdirSync, mkdtempSync, readFileSync, renameSync, rmSync, writeFileSync, } from 'node:fs';
 import { createRequire } from 'node:module';
 import { dirname, isAbsolute, join, relative, resolve, sep } from 'node:path';
 import ts from 'typescript';
-/** Compile one Domain's public runtime package from its dedicated package config. */
-export function compileDomainPackage(projectDir, input) {
+const entrypoint = 'schema/index.ts';
+/** Compile one Domain's admitted Schema contract with SDK-owned emit policy. */
+export function compileDomainPackage(projectDir) {
     const project = resolve(projectDir);
-    const configuration = 'tsconfig.package.json';
-    const configurationPath = resolve(project, configuration);
+    const root = resolve(project, 'dist');
+    rmSync(root, { recursive: true, force: true });
+    const source = resolve(project, entrypoint);
+    if (!existsSync(source))
+        throw new TypeError(`Domain contract entrypoint is absent: ${entrypoint}.`);
+    const configurationPath = resolve(project, 'tsconfig.json');
     const loaded = ts.readConfigFile(configurationPath, ts.sys.readFile);
     if (loaded.error !== undefined)
         failDiagnostics([loaded.error], project);
     const parsed = ts.parseJsonConfigFileContent(loaded.config, ts.sys, project, undefined, configurationPath);
-    const root = parsed.options.outDir && resolve(parsed.options.outDir);
-    if (root !== undefined)
-        confineOutput(project, root);
     if (errors(parsed.errors).length > 0)
         failDiagnostics(parsed.errors, project);
-    if (root === undefined)
-        throw new TypeError(`${configuration} must declare compilerOptions.outDir.`);
-    if (parsed.options.noEmit || !parsed.options.declaration || parsed.options.emitDeclarationOnly) {
-        throw new TypeError(`${configuration} must emit both JavaScript and declarations.`);
-    }
-    if (parsed.options.declarationDir !== undefined &&
-        resolve(parsed.options.declarationDir) !== root) {
-        throw new TypeError(`${configuration} must emit JavaScript and declarations into one outDir.`);
-    }
     if (parsed.fileNames.length === 0)
-        throw new TypeError(`${configuration} compiles no source files.`);
-    if (root !== resolve(project, 'dist')) {
-        throw new TypeError('Domain package output must be the project dist directory.');
-    }
-    const declarationFiles = input.declarations.map((entrypoint) => declarationSource(project, root, parsed.options.rootDir, entrypoint));
+        throw new TypeError('tsconfig.json compiles no source files.');
     const temporary = mkdtempSync(join(project, '.astrale-package-'));
-    const declarationConfiguration = resolve(temporary, 'tsconfig.json');
-    writeFileSync(declarationConfiguration, JSON.stringify({
+    const packageConfiguration = resolve(temporary, 'tsconfig.json');
+    writeFileSync(packageConfiguration, JSON.stringify({
         extends: configurationPath,
         compilerOptions: {
+            rootDir: project,
+            outDir: root,
             noEmit: false,
             declaration: true,
             declarationMap: false,
             sourceMap: false,
-            emitDeclarationOnly: true,
+            inlineSourceMap: false,
+            inlineSources: false,
+            allowImportingTsExtensions: false,
+            emitDeclarationOnly: false,
+            noEmitOnError: true,
+            composite: false,
+            incremental: false,
         },
-        files: declarationFiles,
+        files: [source],
         include: [],
+        exclude: [],
     }));
     try {
-        runCompiler(project, ['-p', resolve(project, 'tsconfig.json'), '--noEmit']);
+        const typeClosure = admitSchemaClosure(project, packageConfiguration);
         runCompiler(project, ['-p', configurationPath, '--noEmit']);
-        rmSync(root, { recursive: true, force: true });
-        runCompiler(project, [
-            '-p',
-            configurationPath,
-            '--noEmit',
-            'false',
-            '--declaration',
-            'false',
-            '--declarationMap',
-            'false',
-            '--sourceMap',
-            'false',
-            '--emitDeclarationOnly',
-            'false',
-        ]);
-        runCompiler(project, ['-p', declarationConfiguration]);
+        runCompiler(project, ['-p', packageConfiguration]);
+        relocateTypeClosure(root, typeClosure);
+        return Object.freeze({ root, typeClosure });
     }
     catch (cause) {
         rmSync(root, { recursive: true, force: true });
@@ -73,7 +58,109 @@ export function compileDomainPackage(projectDir, input) {
     finally {
         rmSync(temporary, { recursive: true, force: true });
     }
-    return Object.freeze({ root });
+}
+function admitSchemaClosure(project, configuration) {
+    const loaded = ts.readConfigFile(configuration, ts.sys.readFile);
+    if (loaded.error !== undefined)
+        failDiagnostics([loaded.error], project);
+    const parsed = ts.parseJsonConfigFileContent(loaded.config, ts.sys, project, undefined, configuration);
+    if (errors(parsed.errors).length > 0)
+        failDiagnostics(parsed.errors, project);
+    const program = ts.createProgram(parsed.fileNames, parsed.options);
+    const local = new Map();
+    for (const document of program.getSourceFiles()) {
+        const path = relative(project, document.fileName);
+        if (path === '..' ||
+            path.startsWith(`..${sep}`) ||
+            isAbsolute(path) ||
+            path === 'node_modules' ||
+            path.startsWith(`node_modules${sep}`)) {
+            continue;
+        }
+        local.set(resolve(document.fileName), document);
+    }
+    for (const document of local.values()) {
+        const owner = relative(project, document.fileName).replaceAll('\\', '/');
+        if (!owner.startsWith('schema/'))
+            continue;
+        const visit = (node) => {
+            const specifier = referencedModule(node);
+            if (specifier !== undefined) {
+                const resolved = ts.resolveModuleName(specifier, document.fileName, parsed.options, ts.sys)
+                    .resolvedModule?.resolvedFileName;
+                if (resolved !== undefined) {
+                    const dependency = local.get(resolve(resolved));
+                    if (dependency !== undefined) {
+                        const path = relative(project, dependency.fileName).replaceAll('\\', '/');
+                        if (!path.startsWith('schema/') && !isTypeOnlyReference(node)) {
+                            throw new TypeError(`Domain Schema contract imports non-Schema source: ${path}.`);
+                        }
+                    }
+                }
+            }
+            ts.forEachChild(node, visit);
+        };
+        visit(document);
+    }
+    return Object.freeze([...local.values()]
+        .map((document) => relative(project, document.fileName).replaceAll('\\', '/'))
+        .filter((path) => !path.startsWith('schema/'))
+        .sort()
+        .map((source) => Object.freeze({
+        source,
+        target: `schema/.types/${source.replace(/\.(?:tsx?|mts|cts)$/u, '.js')}`,
+    })));
+}
+function referencedModule(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 > 0 &&
+        ts.isStringLiteral(node.arguments[0]) &&
+        (node.expression.kind === ts.SyntaxKind.ImportKeyword ||
+            (ts.isIdentifier(node.expression) && node.expression.text === 'require'))) {
+        return node.arguments[0].text;
+    }
+    return undefined;
+}
+function isTypeOnlyReference(node) {
+    if (ts.isImportTypeNode(node))
+        return true;
+    if (ts.isExportDeclaration(node))
+        return node.isTypeOnly;
+    if (!ts.isImportDeclaration(node))
+        return false;
+    const clause = node.importClause;
+    if (clause?.isTypeOnly)
+        return true;
+    if (clause?.name !== undefined || clause?.namedBindings === undefined)
+        return false;
+    return (ts.isNamedImports(clause.namedBindings) &&
+        clause.namedBindings.elements.length > 0 &&
+        clause.namedBindings.elements.every((element) => element.isTypeOnly));
+}
+function relocateTypeClosure(root, closure) {
+    for (const { source, target } of closure) {
+        const emitted = resolve(root, source.replace(/\.(?:tsx?|mts|cts)$/u, ''));
+        const declaration = `${emitted}.d.ts`;
+        if (!existsSync(declaration)) {
+            throw new TypeError(`Domain contract type closure declaration is absent: ${source}.`);
+        }
+        const destination = resolve(root, target.replace(/\.js$/u, '.d.ts'));
+        mkdirSync(dirname(destination), { recursive: true });
+        renameSync(declaration, destination);
+        for (const extension of ['.js', '.mjs', '.cjs', '.jsx']) {
+            rmSync(`${emitted}${extension}`, { force: true });
+        }
+    }
 }
 function runCompiler(project, arguments_) {
     const compiler = resolveCompiler();
@@ -113,30 +200,6 @@ function resolveCompiler() {
     }
     return compiler;
 }
-function declarationSource(project, output, rootDir, entrypoint) {
-    const emitted = relative(output, resolve(project, entrypoint));
-    if (emitted === '..' || emitted.startsWith(`..${sep}`) || isAbsolute(emitted)) {
-        throw new TypeError(`Published declaration entrypoint escapes package output: ${entrypoint}.`);
-    }
-    const source = emitted
-        .replace(/\.d\.mts$/u, '.mts')
-        .replace(/\.d\.cts$/u, '.cts')
-        .replace(/\.d\.ts$/u, '.ts');
-    if (source === emitted) {
-        throw new TypeError(`Published declaration entrypoint is not a declaration: ${entrypoint}.`);
-    }
-    const file = resolve(rootDir === undefined ? project : rootDir, source);
-    if (!existsSync(file)) {
-        throw new TypeError(`Published declaration source is absent: ${source}.`);
-    }
-    return file;
-}
-function confineOutput(project, output) {
-    const path = relative(project, output);
-    if (path === '' || path === '..' || path.startsWith(`..${sep}`) || isAbsolute(path)) {
-        throw new TypeError('Domain package output must be a child of the project root.');
-    }
-}
 function errors(diagnostics) {
     return diagnostics.filter(({ category }) => category === ts.DiagnosticCategory.Error);
 }

package/dist/tooling/packaging/declarations/normalize.js

@@ -8,6 +8,7 @@ export async function normalizeDeclarations(input) {
     const root = resolve(input.root);
     const output = new Map();
     const admittedFacades = new Map();
+    const admittedImports = admitPackageImports(input.imports ?? {});
     let replacements = 0;
     const files = reachableDeclarations(root, input.entrypoints, input.imports);
     const unreachable = allDeclarations(root).filter((file) => !files.includes(file));
@@ -17,6 +18,10 @@ export async function normalizeDeclarations(input) {
             if (specifier.startsWith('.')) {
                 return runtimeSpecifier(file, resolveLocal(file, specifier));
             }
+            if (specifier.startsWith('#')) {
+                const target = resolvePackageImport(specifier, admittedImports);
+                return runtimeSpecifier(file, resolveImportTarget(root, target));
+            }
             const key = JSON.stringify([specifier, symbols]);
             if (admittedFacades.has(key))
                 return admittedFacades.get(key);
@@ -107,7 +112,7 @@ function runtimeSpecifier(containing, declaration) {
         .replace(/\.d\.cts$/u, '.cjs')
         .replace(/\.d\.ts$/u, '.js');
     const path = relative(dirname(containing), runtime).replaceAll('\\', '/');
-    return path.startsWith('.') ? path : `./${path}`;
+    return path.startsWith('./') || path.startsWith('../') ? path : `./${path}`;
 }
 function confined(root, file) {
     const path = relative(realpathSync(root), realpathSync(file));

package/dist/tooling/packaging/exports.js

@@ -4,14 +4,14 @@ import { isAbsolute, relative, resolve, sep } from 'node:path';
 export function verifyPublishedJavaScript(projectDir, manifest) {
     const project = resolve(projectDir);
     const targets = new Set();
-    collectRuntimeTarget(manifest.publishConfig?.main ?? manifest.main, targets, false);
+    collectJavaScriptTarget(manifest.publishConfig?.main ?? manifest.main, targets, false);
     collectExports(manifest.publishConfig?.exports ?? manifest.exports, targets);
     if (targets.size === 0) {
-        throw new TypeError('Published Domain package declares no JavaScript runtime export.');
+        throw new TypeError('Published Domain contract declares no JavaScript export.');
     }
     for (const target of [...targets].sort()) {
         if (!target.startsWith('./dist/') || !/\.(?:c|m)?js$/u.test(target)) {
-            throw new TypeError(`Published runtime export must target emitted JavaScript under ./dist: ${target}.`);
+            throw new TypeError(`Published contract export must target emitted JavaScript under ./dist: ${target}.`);
         }
         const file = resolve(project, target);
         const path = relative(project, file);
@@ -23,7 +23,7 @@ export function verifyPublishedJavaScript(projectDir, manifest) {
         }
     }
 }
-function collectRuntimeTarget(value, targets, types) {
+function collectJavaScriptTarget(value, targets, types) {
     if (typeof value === 'string') {
         if (!types)
             targets.add(value);
@@ -31,24 +31,24 @@ function collectRuntimeTarget(value, targets, types) {
     }
     if (Array.isArray(value)) {
         for (const nested of value)
-            collectRuntimeTarget(nested, targets, types);
+            collectJavaScriptTarget(nested, targets, types);
         return;
     }
     if (value === null || typeof value !== 'object')
         return;
     for (const [condition, nested] of Object.entries(value)) {
-        collectRuntimeTarget(nested, targets, types || condition === 'types');
+        collectJavaScriptTarget(nested, targets, types || condition === 'types');
     }
 }
 function collectExports(value, targets) {
     if (value === null || typeof value !== 'object' || Array.isArray(value)) {
-        collectRuntimeTarget(value, targets, false);
+        collectJavaScriptTarget(value, targets, false);
         return;
     }
     const entries = Object.entries(value);
     const subpaths = entries.filter(([key]) => key.startsWith('.'));
     if (subpaths.length === 0) {
-        collectRuntimeTarget(value, targets, false);
+        collectJavaScriptTarget(value, targets, false);
         return;
     }
     if (subpaths.length !== entries.length) {
@@ -56,6 +56,6 @@ function collectExports(value, targets) {
     }
     for (const [subpath, target] of subpaths) {
         if (subpath !== './package.json')
-            collectRuntimeTarget(target, targets, false);
+            collectJavaScriptTarget(target, targets, false);
     }
 }

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

@@ -0,0 +1,2 @@
+/** Verify emitted Schema JavaScript and return its complete external package set. */
+export declare function verifyContractJavaScript(root: string): readonly string[];

package/dist/tooling/packaging/{runtime.js → javascript.js}

@@ -1,32 +1,30 @@
-import { mkdirSync, readFileSync, readdirSync, writeFileSync } from 'node:fs';
-import { dirname, isAbsolute, join, relative, resolve, sep } from 'node:path';
+import { readFileSync, readdirSync } from 'node:fs';
+import { join } from 'node:path';
 import ts from 'typescript';
-/** Reject direct Kernel runtime imports from a packaged product Domain. */
-export function verifyRuntimeFacades(root) {
-    for (const file of runtimeFiles(root)) {
+/** Verify emitted Schema JavaScript and return its complete external package set. */
+export function verifyContractJavaScript(root) {
+    const packages = new Set();
+    for (const file of javascriptFiles(root)) {
         const source = readFileSync(file, 'utf8');
         const document = ts.createSourceFile(file, source, ts.ScriptTarget.Latest, true);
         visit(document);
         function visit(node) {
             const specifier = moduleSpecifier(node);
             if (specifier?.startsWith('@astrale-os/kernel-')) {
-                throw new TypeError(`Domain runtime imports a Kernel package directly: ${specifier} in ${file}.`);
+                throw new TypeError(`Domain contract imports a Kernel package directly: ${specifier} in ${file}.`);
+            }
+            if (specifier !== undefined &&
+                !specifier.startsWith('.') &&
+                !specifier.startsWith('#') &&
+                !specifier.startsWith('node:')) {
+                packages.add(packageName(specifier));
             }
             ts.forEachChild(node, visit);
         }
     }
+    return Object.freeze([...packages].sort());
 }
-/** Publish only the admitted Runtime identity; handlers and providers remain package-private. */
-export function writeRuntimeDeclaration(root, entrypoint) {
-    const file = resolve(root, entrypoint);
-    const path = relative(resolve(root), file);
-    if (path === '' || path === '..' || path.startsWith(`..${sep}`) || isAbsolute(path)) {
-        throw new TypeError('Runtime declaration entrypoint escapes package output.');
-    }
-    mkdirSync(dirname(file), { recursive: true });
-    writeFileSync(file, "import type { Runtime } from '@astrale-os/sdk/runtime'\n\ndeclare const runtime: Runtime\nexport default runtime\n");
-}
-function runtimeFiles(root) {
+function javascriptFiles(root) {
     const files = [];
     const visit = (directory) => {
         for (const entry of readdirSync(directory, { withFileTypes: true })) {
@@ -46,7 +44,7 @@ function moduleSpecifier(node) {
         ts.isStringLiteral(node.moduleSpecifier)) {
         return node.moduleSpecifier.text;
     }
-    if (!ts.isCallExpression(node) || node.arguments.length !== 1)
+    if (!ts.isCallExpression(node) || node.arguments.length === 0)
         return undefined;
     const dynamicImport = node.expression.kind === ts.SyntaxKind.ImportKeyword;
     const requireCall = ts.isIdentifier(node.expression) && node.expression.text === 'require';
@@ -55,3 +53,7 @@ function moduleSpecifier(node) {
         ? argument.text
         : undefined;
 }
+function packageName(specifier) {
+    const parts = specifier.split('/');
+    return specifier.startsWith('@') ? `${parts[0]}/${parts[1]}` : parts[0];
+}

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

@@ -6,5 +6,5 @@ export interface PackageDomainResult {
     readonly replacements: number;
     readonly packages: readonly string[];
 }
-/** Compile, normalize, and verify one publishable Domain runtime package. */
+/** Compile, normalize, and verify one public Domain Schema contract package. */
 export declare function packageDomain(input: PackageDomainInput): Promise<PackageDomainResult>;

package/dist/tooling/packaging/packaging.js

@@ -1,92 +1,120 @@
 import { readFile } from 'node:fs/promises';
+import { rm } from 'node:fs/promises';
 import { resolve } from 'node:path';
 import { admitDomainPackage } from './admission.js';
 import { compileDomainPackage } from './compile.js';
 import { normalizeDeclarations, verifyDeclarationPackage } from './declarations/index.js';
 import { verifyPublishedJavaScript } from './exports.js';
-import { verifyRuntimeFacades, writeRuntimeDeclaration } from './runtime.js';
-/** Compile, normalize, and verify one publishable Domain runtime package. */
+import { verifyContractJavaScript } from './javascript.js';
+/** Compile, normalize, and verify one public Domain Schema contract package. */
 export async function packageDomain(input) {
     const projectDir = resolve(input.projectDir);
     const manifest = JSON.parse(await readFile(resolve(projectDir, 'package.json'), 'utf8'));
     admitDomainPackage(projectDir, manifest);
-    const publishedEntrypoints = declarationEntrypoints(manifest);
-    const publishedRuntime = runtimeDeclarationEntrypoint(manifest);
-    const { root } = compileDomainPackage(projectDir, {
-        declarations: publishedEntrypoints.filter((entrypoint) => entrypoint !== publishedRuntime),
-    });
-    const output = relativeOutputRoot(projectDir, root);
-    const entrypoints = publishedEntrypoints.map((entrypoint) => relativeOutput(entrypoint, output));
-    const runtimeEntrypoint = publishedRuntime === undefined ? undefined : relativeOutput(publishedRuntime, output);
-    if (runtimeEntrypoint !== undefined)
-        writeRuntimeDeclaration(root, runtimeEntrypoint);
-    verifyPublishedJavaScript(projectDir, manifest);
-    const normalized = await normalizeDeclarations({
-        root,
-        imports: manifest.publishConfig?.imports ?? manifest.imports,
-        entrypoints,
-    });
-    verifyRuntimeFacades(root);
-    const verified = await verifyDeclarationPackage({ root, packageRoot: projectDir, entrypoints });
-    return Object.freeze({
-        declarations: verified.files.length,
-        replacements: normalized.replacements,
-        packages: verified.packages,
-    });
-}
-function relativeOutputRoot(project, output) {
-    return output.slice(project.length + 1).replaceAll('\\', '/');
+    admitContractManifest(manifest);
+    const { root, typeClosure } = compileDomainPackage(projectDir);
+    try {
+        const entrypoints = ['schema/index.d.ts'];
+        verifyPublishedJavaScript(projectDir, manifest);
+        const javascriptPackages = verifyContractJavaScript(root);
+        const normalized = await normalizeDeclarations({
+            root,
+            imports: declarationImports(manifest, typeClosure),
+            entrypoints,
+        });
+        const verified = await verifyDeclarationPackage({ root, packageRoot: projectDir, entrypoints });
+        const packages = Object.freeze([...new Set([...javascriptPackages, ...verified.packages])].sort());
+        verifyDependencies(manifest, packages);
+        return Object.freeze({
+            declarations: verified.files.length,
+            replacements: normalized.replacements,
+            packages,
+        });
+    }
+    catch (cause) {
+        await rm(root, { recursive: true, force: true });
+        throw cause;
+    }
 }
-function declarationEntrypoints(manifest) {
-    const values = new Set();
-    const collect = (value, types = false) => {
-        if (typeof value === 'string') {
-            if (types || /\.d\.(?:ts|mts|cts)$/u.test(value))
-                values.add(normalizePath(value));
-            return;
+function declarationImports(manifest, closure) {
+    const imports = { ...manifest.publishConfig?.imports };
+    for (const { source, target } of closure) {
+        const specifier = packageImportForSource(manifest.imports ?? {}, source);
+        if (specifier === undefined) {
+            throw new TypeError(`Domain contract type closure has no package import: ${source}.`);
         }
-        if (!value || typeof value !== 'object')
-            return;
-        for (const [condition, nested] of Object.entries(value))
-            collect(nested, condition === 'types');
-    };
-    const published = manifest.publishConfig;
-    collect(published?.types ?? manifest.types, true);
-    collect(published?.exports ?? manifest.exports);
-    if (values.size === 0)
-        throw new TypeError('Published Domain package declares no TypeScript entrypoint.');
-    return Object.freeze([...values].sort());
+        imports[specifier] = `./dist/${target}`;
+    }
+    return Object.keys(imports).length === 0 ? undefined : imports;
 }
-function runtimeDeclarationEntrypoint(manifest) {
-    const exports = manifest.publishConfig?.exports ?? manifest.exports;
-    if (exports === null || typeof exports !== 'object' || Array.isArray(exports))
-        return undefined;
-    const runtime = exports['./runtime'];
-    if (runtime === undefined)
-        return undefined;
-    const values = [];
-    const collect = (value, types = false) => {
-        if (typeof value === 'string') {
-            if (types || /\.d\.(?:ts|mts|cts)$/u.test(value))
-                values.push(normalizePath(value));
-            return;
+function packageImportForSource(imports, source) {
+    for (const [specifier, target] of Object.entries(imports).sort(([left], [right]) => left.localeCompare(right))) {
+        if (typeof target !== 'string')
+            continue;
+        const normalized = target.replace(/^\.\//u, '');
+        const wildcard = normalized.indexOf('*');
+        if (wildcard === -1) {
+            if (normalized === source)
+                return specifier;
+            continue;
         }
-        if (value === null || typeof value !== 'object')
-            return;
-        for (const [condition, nested] of Object.entries(value))
-            collect(nested, condition === 'types');
-    };
-    collect(runtime);
-    if (values.length !== 1) {
-        throw new TypeError('Published Domain ./runtime must declare exactly one TypeScript entrypoint.');
+        const prefix = normalized.slice(0, wildcard);
+        const suffix = normalized.slice(wildcard + 1);
+        if (!source.startsWith(prefix) || !source.endsWith(suffix))
+            continue;
+        const value = source.slice(prefix.length, source.length - suffix.length);
+        return specifier.replace('*', value);
+    }
+    return undefined;
+}
+function admitContractManifest(manifest) {
+    if (manifest.files?.length !== 1 || manifest.files[0] !== 'dist') {
+        throw new TypeError('Domain contract package files must be exactly ["dist"].');
+    }
+    if (manifest.main !== './schema/index.ts' || manifest.types !== './schema/index.ts') {
+        throw new TypeError('Domain contract source entrypoint must be ./schema/index.ts.');
     }
-    return values[0];
+    admitExports(manifest.exports, './schema/index.ts', './schema/index.ts', 'source');
+    const published = manifest.publishConfig;
+    if (published?.main !== './dist/schema/index.js' ||
+        published.types !== './dist/schema/index.d.ts') {
+        throw new TypeError('Published Domain contract entrypoint must be ./dist/schema/index.js.');
+    }
+    admitExports(published.exports, './dist/schema/index.d.ts', './dist/schema/index.js', 'published');
 }
-function normalizePath(file) {
-    return file.replace(/^\.\//u, '').replaceAll('\\', '/');
+function admitExports(exports, types, imported, label) {
+    if (exports === null || typeof exports !== 'object' || Array.isArray(exports)) {
+        throw new TypeError(`Domain contract ${label} exports must be an object.`);
+    }
+    const record = exports;
+    const keys = Object.keys(record).sort();
+    if (keys.length !== 2 || keys[0] !== '.' || keys[1] !== './package.json') {
+        throw new TypeError(`Domain contract ${label} exports must contain only "." and "./package.json".`);
+    }
+    const root = record['.'];
+    if (root === undefined ||
+        typeof root !== 'object' ||
+        root.types !== types ||
+        root.import !== imported) {
+        throw new TypeError(`Domain contract ${label} root export is invalid.`);
+    }
+    if (record['./package.json'] !== './package.json') {
+        throw new TypeError(`Domain contract ${label} package metadata export is invalid.`);
+    }
 }
-function relativeOutput(file, output) {
-    const normalized = file.replace(/^\.\//u, '');
-    const prefix = `${output.replace(/^\.\//u, '').replace(/\/$/u, '')}/`;
-    return normalized.startsWith(prefix) ? normalized.slice(prefix.length) : normalized;
+function verifyDependencies(manifest, packages) {
+    const declared = new Set([
+        ...Object.keys(manifest.dependencies ?? {}),
+        ...Object.keys(manifest.optionalDependencies ?? {}),
+        ...Object.keys(manifest.peerDependencies ?? {}),
+    ]);
+    const used = new Set(packages);
+    const missing = packages.filter((name) => !declared.has(name));
+    if (missing.length > 0) {
+        throw new TypeError(`Published Domain contract references undeclared packages: ${missing.join(', ')}.`);
+    }
+    const unused = [...declared].filter((name) => !used.has(name)).sort();
+    if (unused.length > 0) {
+        throw new TypeError(`Domain contract declares unused production packages: ${unused.join(', ')}.`);
+    }
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@astrale-os/sdk",
-  "version": "0.5.0-beta.43",
+  "version": "0.5.0-beta.44",
   "description": "Schema-first SDK for defining, composing, and deploying Astrale domains",
   "keywords": [
     "astrale",

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

@@ -1,4 +0,0 @@
-/** Reject direct Kernel runtime imports from a packaged product Domain. */
-export declare function verifyRuntimeFacades(root: string): void;
-/** Publish only the admitted Runtime identity; handlers and providers remain package-private. */
-export declare function writeRuntimeDeclaration(root: string, entrypoint: string): void;