@astrale-os/sdk 0.5.0-beta.8 → 0.5.0-beta.80

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

@@ -0,0 +1,135 @@
+import { existsSync, readFileSync, readdirSync, realpathSync, rmSync, writeFileSync } from 'node:fs';
+import { dirname, isAbsolute, join, relative, resolve } from 'node:path';
+import { admitPackageImports, resolvePackageImport } from './imports.js';
+import { declarationReferences } from './references.js';
+import { declarationEdits, declarationFacade } from './transform.js';
+/** Normalize emitted declarations without re-emitting or re-typechecking their source program. */
+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));
+    for (const file of files) {
+        const source = readFileSync(file, 'utf8');
+        const fileEdits = declarationEdits(file, source, (specifier, symbols) => {
+            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);
+            const facade = declarationFacade(specifier, symbols);
+            admittedFacades.set(key, facade);
+            return facade;
+        });
+        const normalized = stripSourceMapReference(apply(source, fileEdits));
+        if (normalized.includes('@astrale-os/kernel-')) {
+            throw new TypeError(`Domain declaration retains a Kernel package specifier: ${file}.`);
+        }
+        output.set(file, normalized);
+        replacements += fileEdits.length;
+    }
+    for (const [file, source] of output)
+        writeFileSync(file, source);
+    for (const file of files)
+        rmSync(`${file}.map`, { force: true });
+    for (const file of unreachable) {
+        rmSync(file);
+        rmSync(`${file}.map`, { force: true });
+    }
+    return Object.freeze({
+        files: Object.freeze(files),
+        replacements,
+    });
+}
+function allDeclarations(root) {
+    const files = [];
+    const visit = (directory) => {
+        for (const entry of readdirSync(directory, { withFileTypes: true })) {
+            const path = join(directory, entry.name);
+            if (entry.isDirectory())
+                visit(path);
+            else if (/\.d\.(?:ts|mts|cts)$/u.test(path))
+                files.push(path);
+        }
+    };
+    visit(root);
+    return files.sort();
+}
+export function reachableDeclarations(root, requested, imports = {}) {
+    const admittedImports = admitPackageImports(imports);
+    const pending = (requested ?? ['index.d.ts']).map((entry) => confined(root, resolve(root, entry)));
+    const seen = new Set();
+    while (pending.length > 0) {
+        const file = pending.pop();
+        if (seen.has(file))
+            continue;
+        if (!existsSync(file))
+            throw new TypeError(`Declaration entrypoint does not exist: ${file}.`);
+        seen.add(file);
+        const source = readFileSync(file, 'utf8');
+        for (const reference of declarationReferences(file, source)) {
+            if (reference.kind === 'path' || reference.specifier.startsWith('.')) {
+                pending.push(confined(root, resolveLocal(file, reference.specifier)));
+            }
+            else if (reference.specifier.startsWith('#')) {
+                const target = resolvePackageImport(reference.specifier, admittedImports);
+                pending.push(confined(root, resolveImportTarget(root, target)));
+            }
+        }
+    }
+    return [...seen].sort();
+}
+function resolveImportTarget(root, target) {
+    return resolveLocal(join(root, 'entry.d.ts'), `./${target.slice('./dist/'.length)}`);
+}
+function resolveLocal(containing, specifier) {
+    const base = resolve(dirname(containing), specifier);
+    const candidates = [
+        base.endsWith('.mjs') ? base.replace(/\.mjs$/u, '.d.mts') : '',
+        base.endsWith('.cjs') ? base.replace(/\.cjs$/u, '.d.cts') : '',
+        base.endsWith('.js') ? base.replace(/\.js$/u, '.d.ts') : '',
+        /\.d\.(?:ts|mts|cts)$/u.test(base) ? base : '',
+        `${base}.d.ts`,
+        join(base, 'index.d.ts'),
+    ];
+    const file = candidates.find((candidate) => candidate && existsSync(candidate));
+    if (!file)
+        throw new TypeError(`Cannot resolve declaration reference ${specifier} from ${containing}.`);
+    return file;
+}
+/** Point a local declaration reference at the emitted ESM module that owns it. */
+function runtimeSpecifier(containing, declaration) {
+    const runtime = declaration
+        .replace(/\.d\.mts$/u, '.mjs')
+        .replace(/\.d\.cts$/u, '.cjs')
+        .replace(/\.d\.ts$/u, '.js');
+    const path = relative(dirname(containing), runtime).replaceAll('\\', '/');
+    return path.startsWith('./') || path.startsWith('../') ? path : `./${path}`;
+}
+function confined(root, file) {
+    const path = relative(realpathSync(root), realpathSync(file));
+    if (path === '..' ||
+        path.startsWith(`..${process.platform === 'win32' ? '\\' : '/'}`) ||
+        isAbsolute(path)) {
+        throw new TypeError(`Declaration reference escapes package root: ${file}.`);
+    }
+    return file;
+}
+function apply(source, edits) {
+    let result = source;
+    for (const edit of [...edits].sort((left, right) => right.start - left.start)) {
+        result = `${result.slice(0, edit.start)}${edit.replacement}${result.slice(edit.end)}`;
+    }
+    return result;
+}
+function stripSourceMapReference(source) {
+    return source.replace(/^\/\/# sourceMappingURL=.*(?:\r?\n|$)/gmu, '');
+}

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

@@ -0,0 +1,9 @@
+/**
+ * Return the explicit SDK facade registry after proving every owner is public.
+ *
+ * This small list records semantic ownership only. Kernel symbols remain
+ * discovered and identity-proven by the TypeScript checker at packaging time.
+ */
+export declare function declarationFacades(anchor?: string): readonly string[];
+/** Whether one eligible facade is semantically broader than another. */
+export declare function isDeclarationFacadeAncestor(ancestor: string, descendant: string): boolean;

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

@@ -0,0 +1,85 @@
+import { existsSync, readFileSync } from 'node:fs';
+import { dirname, join, relative, resolve, sep } from 'node:path';
+/** Stable semantic owners eligible to appear in a product Domain declaration. */
+const semanticFacades = Object.freeze([
+    '@astrale-os/sdk/auth',
+    '@astrale-os/sdk/auth/exchange',
+    '@astrale-os/sdk/client',
+    '@astrale-os/sdk/client/schema',
+    '@astrale-os/sdk/client/session',
+    '@astrale-os/sdk/client/store',
+    '@astrale-os/sdk/graph',
+    '@astrale-os/sdk/graph/class',
+    '@astrale-os/sdk/graph/document',
+    '@astrale-os/sdk/graph/edge',
+    '@astrale-os/sdk/graph/node',
+    '@astrale-os/sdk/graph/path',
+    '@astrale-os/sdk/graph/properties',
+    '@astrale-os/sdk/invocation',
+    '@astrale-os/sdk/publication',
+    '@astrale-os/sdk/schema',
+    '@astrale-os/sdk/value',
+]);
+/** Broad authoring aggregates yield to an exact semantic facade exporting the same symbol. */
+const aggregateFacades = new Set(['@astrale-os/sdk/schema']);
+/**
+ * Return the explicit SDK facade registry after proving every owner is public.
+ *
+ * This small list records semantic ownership only. Kernel symbols remain
+ * discovered and identity-proven by the TypeScript checker at packaging time.
+ */
+export function declarationFacades(anchor = import.meta.filename) {
+    const root = sdkRoot(anchor);
+    const manifest = JSON.parse(readFileSync(join(root, 'package.json'), 'utf8'));
+    if (manifest.name !== '@astrale-os/sdk') {
+        throw new TypeError(`Declaration packaging resolved a non-SDK package at ${root}.`);
+    }
+    const exports = sourceTree(anchor, root)
+        ? manifest.exports
+        : (manifest.publishConfig?.exports ?? manifest.exports);
+    if (exports === undefined)
+        throw new TypeError('SDK package declares no public exports.');
+    for (const facade of semanticFacades) {
+        const key = `./${facade.slice('@astrale-os/sdk/'.length)}`;
+        const entry = exports[key];
+        if (entry === undefined ||
+            typeof entry === 'string' ||
+            typeof entry.types !== 'string' ||
+            !platformTarget(entry.types)) {
+            throw new TypeError(`SDK semantic declaration facade is not publicly exported: ${facade}.`);
+        }
+    }
+    return semanticFacades;
+}
+/** Whether one eligible facade is semantically broader than another. */
+export function isDeclarationFacadeAncestor(ancestor, descendant) {
+    return descendant.startsWith(`${ancestor}/`) || aggregateFacades.has(ancestor);
+}
+function sdkRoot(anchor) {
+    let directory = dirname(anchor);
+    for (;;) {
+        const manifest = join(directory, 'package.json');
+        if (existsSync(manifest)) {
+            try {
+                const parsed = JSON.parse(readFileSync(manifest, 'utf8'));
+                if (parsed.name === '@astrale-os/sdk')
+                    return directory;
+            }
+            catch {
+                // A nearer malformed or unrelated manifest is not the SDK package.
+            }
+        }
+        const parent = dirname(directory);
+        if (parent === directory)
+            break;
+        directory = parent;
+    }
+    throw new TypeError(`Cannot locate @astrale-os/sdk from ${anchor}.`);
+}
+function sourceTree(anchor, root) {
+    const path = relative(resolve(root, 'src'), resolve(anchor));
+    return path === '' || (path !== '..' && !path.startsWith(`..${sep}`));
+}
+function platformTarget(target) {
+    return /^\.\/(?:src|dist)\/platform\//u.test(target);
+}

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

@@ -0,0 +1,5 @@
+export interface DeclarationReference {
+    readonly kind: 'module' | 'path' | 'types';
+    readonly specifier: string;
+}
+export declare function declarationReferences(file: string, source: string): readonly DeclarationReference[];

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

@@ -0,0 +1,38 @@
+import ts from 'typescript';
+export function declarationReferences(file, source) {
+    const document = ts.createSourceFile(file, source, ts.ScriptTarget.Latest, true);
+    const references = [
+        ...document.referencedFiles.map(({ fileName }) => ({
+            kind: 'path',
+            specifier: fileName,
+        })),
+        ...document.typeReferenceDirectives.map(({ fileName }) => ({
+            kind: 'types',
+            specifier: fileName,
+        })),
+    ];
+    const visit = (node) => {
+        let literal;
+        if (ts.isImportDeclaration(node) && ts.isStringLiteral(node.moduleSpecifier))
+            literal = node.moduleSpecifier;
+        else if (ts.isExportDeclaration(node) &&
+            node.moduleSpecifier &&
+            ts.isStringLiteral(node.moduleSpecifier))
+            literal = node.moduleSpecifier;
+        else if (ts.isImportTypeNode(node) &&
+            ts.isLiteralTypeNode(node.argument) &&
+            ts.isStringLiteral(node.argument.literal))
+            literal = node.argument.literal;
+        else if (ts.isImportEqualsDeclaration(node) &&
+            ts.isExternalModuleReference(node.moduleReference)) {
+            const expression = node.moduleReference.expression;
+            if (expression && ts.isStringLiteral(expression))
+                literal = expression;
+        }
+        if (literal)
+            references.push({ kind: 'module', specifier: literal.text });
+        ts.forEachChild(node, visit);
+    };
+    visit(document);
+    return Object.freeze(references);
+}

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

@@ -0,0 +1,11 @@
+export interface DeclarationEdit {
+    readonly start: number;
+    readonly end: number;
+    readonly replacement: string;
+}
+type ResolveDeclarationFacade = (specifier: string, symbols: readonly string[]) => string | undefined;
+/** Locate only TypeScript declaration module specifiers; returned edits preserve all other bytes. */
+export declare function declarationEdits(file: string, source: string, resolveFacade?: ResolveDeclarationFacade): readonly DeclarationEdit[];
+/** Canonical SDK facade for one Kernel module emitted into a Domain declaration. */
+export declare function declarationFacade(specifier: string, symbols: readonly string[]): string | undefined;
+export {};

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

@@ -0,0 +1,76 @@
+import ts from 'typescript';
+import { admitDeclarationFacade } from './admission.js';
+/** Locate only TypeScript declaration module specifiers; returned edits preserve all other bytes. */
+export function declarationEdits(file, source, resolveFacade = declarationFacade) {
+    const document = ts.createSourceFile(file, source, ts.ScriptTarget.Latest, true, ts.ScriptKind.TS);
+    const edits = [];
+    visit(document);
+    return Object.freeze(edits);
+    function visit(node) {
+        if (ts.isImportDeclaration(node) && ts.isStringLiteral(node.moduleSpecifier)) {
+            append(node.moduleSpecifier);
+        }
+        else if (ts.isExportDeclaration(node) &&
+            node.moduleSpecifier !== undefined &&
+            ts.isStringLiteral(node.moduleSpecifier)) {
+            append(node.moduleSpecifier);
+        }
+        else if (ts.isImportTypeNode(node) &&
+            ts.isLiteralTypeNode(node.argument) &&
+            ts.isStringLiteral(node.argument.literal)) {
+            append(node.argument.literal);
+        }
+        ts.forEachChild(node, visit);
+    }
+    function append(literal) {
+        const symbols = literal.text.startsWith(KERNEL_PREFIX) ? importedSymbols(literal) : [];
+        const replacement = resolveFacade(literal.text, symbols);
+        if (replacement === undefined || replacement === literal.text)
+            return;
+        const start = literal.getStart(document) + 1;
+        const end = literal.getEnd() - 1;
+        edits.push(Object.freeze({
+            start,
+            end,
+            replacement,
+        }));
+    }
+}
+function importedSymbols(literal) {
+    const owner = literal.parent;
+    if (ts.isImportDeclaration(owner)) {
+        const clause = owner.importClause;
+        if (!clause ||
+            clause.name ||
+            !clause.namedBindings ||
+            ts.isNamespaceImport(clause.namedBindings)) {
+            throw new TypeError(`Kernel declaration imports must use explicit named symbols: ${literal.text}.`);
+        }
+        return clause.namedBindings.elements.map((element) => (element.propertyName ?? element.name).text);
+    }
+    if (ts.isExportDeclaration(owner)) {
+        if (!owner.exportClause || ts.isNamespaceExport(owner.exportClause)) {
+            throw new TypeError(`Kernel declaration exports must use explicit named symbols: ${literal.text}.`);
+        }
+        return owner.exportClause.elements.map((element) => (element.propertyName ?? element.name).text);
+    }
+    if (ts.isLiteralTypeNode(owner) && ts.isImportTypeNode(owner.parent)) {
+        const qualifier = owner.parent.qualifier;
+        if (!qualifier) {
+            throw new TypeError(`Kernel declaration import types must select an explicit symbol: ${literal.text}.`);
+        }
+        let selected = qualifier;
+        while (ts.isQualifiedName(selected))
+            selected = selected.left;
+        return [selected.text];
+    }
+    throw new TypeError(`Unsupported Kernel declaration reference: ${literal.text}.`);
+}
+const KERNEL_PREFIX = '@astrale-os/kernel-';
+/** Canonical SDK facade for one Kernel module emitted into a Domain declaration. */
+export function declarationFacade(specifier, symbols) {
+    if (specifier.startsWith(KERNEL_PREFIX)) {
+        return admitDeclarationFacade({ source: specifier, symbols });
+    }
+    return undefined;
+}

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

@@ -0,0 +1,11 @@
+export interface DeclarationPackageInput {
+    readonly root: string;
+    readonly packageRoot: string;
+    readonly entrypoints?: readonly string[];
+}
+export interface DeclarationPackageResult {
+    readonly files: readonly string[];
+    readonly packages: readonly string[];
+}
+/** Verify the complete public declaration graph against one published package manifest. */
+export declare function verifyDeclarationPackage(input: DeclarationPackageInput): Promise<DeclarationPackageResult>;

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

@@ -0,0 +1,44 @@
+import { readFileSync } from 'node:fs';
+import { resolve } from 'node:path';
+import { admitSelfPackage, isSelfPackageReference, packageName } from '../self.js';
+import { reachableDeclarations } from './normalize.js';
+import { declarationReferences } from './references.js';
+/** Verify the complete public declaration graph against one published package manifest. */
+export async function verifyDeclarationPackage(input) {
+    const manifest = JSON.parse(readFileSync(resolve(input.packageRoot, 'package.json'), 'utf8'));
+    const files = reachableDeclarations(resolve(input.root), input.entrypoints, manifest.publishConfig?.imports ?? manifest.imports);
+    const self = manifest.name === undefined
+        ? undefined
+        : admitSelfPackage(manifest.name, exportSubpaths(manifest.exports));
+    const packages = new Set();
+    for (const file of files) {
+        for (const reference of declarationReferences(file, readFileSync(file, 'utf8'))) {
+            const specifier = reference.specifier;
+            if (reference.kind !== 'path' &&
+                !specifier.startsWith('.') &&
+                !specifier.startsWith('#') &&
+                !specifier.startsWith('node:') &&
+                !isSelfPackageReference(specifier, self)) {
+                packages.add(packageName(specifier));
+            }
+        }
+    }
+    const declared = new Set([
+        ...Object.keys(manifest.dependencies ?? {}),
+        ...Object.keys(manifest.optionalDependencies ?? {}),
+        ...Object.keys(manifest.peerDependencies ?? {}),
+    ]);
+    const missing = [...packages].filter((name) => !declared.has(name)).sort();
+    if (missing.length > 0) {
+        throw new TypeError(`Published declarations reference undeclared packages: ${missing.join(', ')}.`);
+    }
+    return Object.freeze({
+        files: Object.freeze(files),
+        packages: Object.freeze([...packages].sort()),
+    });
+}
+function exportSubpaths(value) {
+    if (value === null || typeof value !== 'object' || Array.isArray(value))
+        return [];
+    return Object.keys(value).filter((subpath) => subpath !== './package.json');
+}

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

@@ -0,0 +1,11 @@
+interface PackageManifest {
+    readonly main?: string;
+    readonly exports?: unknown;
+    readonly publishConfig?: {
+        readonly main?: string;
+        readonly exports?: unknown;
+    };
+}
+/** Verify that every JavaScript target exposed by the published manifest was emitted. */
+export declare function verifyPublishedJavaScript(projectDir: string, manifest: PackageManifest): void;
+export {};

package/dist/tooling/packaging/exports.js

@@ -0,0 +1,61 @@
+import { existsSync } from 'node:fs';
+import { isAbsolute, relative, resolve, sep } from 'node:path';
+/** Verify that every JavaScript target exposed by the published manifest was emitted. */
+export function verifyPublishedJavaScript(projectDir, manifest) {
+    const project = resolve(projectDir);
+    const targets = new Set();
+    collectJavaScriptTarget(manifest.publishConfig?.main ?? manifest.main, targets, false);
+    collectExports(manifest.publishConfig?.exports ?? manifest.exports, targets);
+    if (targets.size === 0) {
+        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 contract export must target emitted JavaScript under ./dist: ${target}.`);
+        }
+        const file = resolve(project, target);
+        const path = relative(project, file);
+        if (path === '..' || path.startsWith(`..${sep}`) || isAbsolute(path)) {
+            throw new TypeError(`Published JavaScript export target escapes the package: ${target}.`);
+        }
+        if (!existsSync(file)) {
+            throw new TypeError(`Published JavaScript export target is absent: ${target}.`);
+        }
+    }
+}
+function collectJavaScriptTarget(value, targets, types) {
+    if (typeof value === 'string') {
+        if (!types)
+            targets.add(value);
+        return;
+    }
+    if (Array.isArray(value)) {
+        for (const nested of value)
+            collectJavaScriptTarget(nested, targets, types);
+        return;
+    }
+    if (value === null || typeof value !== 'object')
+        return;
+    for (const [condition, nested] of Object.entries(value)) {
+        collectJavaScriptTarget(nested, targets, types || condition === 'types');
+    }
+}
+function collectExports(value, targets) {
+    if (value === null || typeof value !== 'object' || Array.isArray(value)) {
+        collectJavaScriptTarget(value, targets, false);
+        return;
+    }
+    const entries = Object.entries(value);
+    const subpaths = entries.filter(([key]) => key.startsWith('.'));
+    if (subpaths.length === 0) {
+        collectJavaScriptTarget(value, targets, false);
+        return;
+    }
+    if (subpaths.length !== entries.length) {
+        throw new TypeError('Published exports cannot mix package subpaths and runtime conditions.');
+    }
+    for (const [subpath, target] of subpaths) {
+        if (subpath !== './package.json')
+            collectJavaScriptTarget(target, targets, false);
+    }
+}

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

@@ -0,0 +1,2 @@
+export type { PackageDomainInput, PackageDomainResult } from './packaging.js';
+export { packageDomain } from './packaging.js';

package/dist/tooling/packaging/index.js

@@ -0,0 +1 @@
+export { packageDomain } from './packaging.js';

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

@@ -0,0 +1,3 @@
+import { type SelfPackage } from './self.js';
+/** Verify emitted Schema JavaScript and return its complete external package set. */
+export declare function verifyContractJavaScript(root: string, self?: SelfPackage): readonly string[];

package/dist/tooling/packaging/javascript.js

@@ -0,0 +1,71 @@
+import { readFileSync, readdirSync } from 'node:fs';
+import { join } from 'node:path';
+import ts from 'typescript';
+import { isSelfPackageReference, packageName } from './self.js';
+/** Verify emitted Schema JavaScript and return its complete external package set. */
+export function verifyContractJavaScript(root, self) {
+    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 contract imports a Kernel package directly: ${specifier} in ${file}.`);
+            }
+            if (specifier?.startsWith('#')) {
+                throw new TypeError(`Domain contract retains a private package import: ${specifier} in ${file}.`);
+            }
+            if (unsupportedModuleReference(node)) {
+                throw new TypeError(`Domain contract retains unsupported non-static dependency syntax in ${file}.`);
+            }
+            if (specifier !== undefined &&
+                !specifier.startsWith('.') &&
+                !specifier.startsWith('#') &&
+                !specifier.startsWith('node:') &&
+                !isSelfPackageReference(specifier, self)) {
+                packages.add(packageName(specifier));
+            }
+            ts.forEachChild(node, visit);
+        }
+    }
+    return Object.freeze([...packages].sort());
+}
+function unsupportedModuleReference(node) {
+    if (!ts.isCallExpression(node))
+        return false;
+    const dynamicImport = node.expression.kind === ts.SyntaxKind.ImportKeyword;
+    const requireCall = ts.isIdentifier(node.expression) && node.expression.text === 'require';
+    return ((dynamicImport || requireCall) &&
+        (node.arguments.length !== 1 || !ts.isStringLiteral(node.arguments[0])));
+}
+function javascriptFiles(root) {
+    const files = [];
+    const visit = (directory) => {
+        for (const entry of readdirSync(directory, { withFileTypes: true })) {
+            const path = join(directory, entry.name);
+            if (entry.isDirectory())
+                visit(path);
+            else if (/\.(?:js|mjs|cjs)$/u.test(entry.name))
+                files.push(path);
+        }
+    };
+    visit(root);
+    return files.sort();
+}
+function moduleSpecifier(node) {
+    if ((ts.isImportDeclaration(node) || ts.isExportDeclaration(node)) &&
+        node.moduleSpecifier &&
+        ts.isStringLiteral(node.moduleSpecifier)) {
+        return node.moduleSpecifier.text;
+    }
+    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';
+    const argument = node.arguments[0];
+    return (dynamicImport || requireCall) && argument && ts.isStringLiteral(argument)
+        ? argument.text
+        : undefined;
+}

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

@@ -0,0 +1,10 @@
+export interface PackageDomainInput {
+    readonly projectDir: string;
+}
+export interface PackageDomainResult {
+    readonly declarations: number;
+    readonly replacements: number;
+    readonly packages: readonly string[];
+}
+/** Compile, normalize, and verify every public Schema contract in one Domain package. */
+export declare function packageDomain(input: PackageDomainInput): Promise<PackageDomainResult>;