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

package/dist/tooling/cli/registry/installations.js

@@ -0,0 +1,108 @@
+import { RegistryCliError } from './error.js';
+/**
+ * Decode one `astrale.installed-list` v1 document: the instance Kernel that answered, whether the
+ * listing may omit installations (`partial`, required) and the deployment URL of each
+ * installation. Anything else is refused.
+ */
+export function decodeInstanceListing(document) {
+    if (document.format !== 'astrale.installed-list' ||
+        document.version !== 1 ||
+        !httpUrl(document.kernel) ||
+        typeof document.partial !== 'boolean' ||
+        !Array.isArray(document.domains)) {
+        throw protocolError('Astrale CLI answered no installed list of the instance.');
+    }
+    return Object.freeze({
+        kind: 'listed',
+        kernel: document.kernel,
+        partial: document.partial,
+        installations: Object.freeze(document.domains.map((entry) => {
+            if (!isRecord(entry) || !text(entry.origin) || !httpUrl(entry.url)) {
+                throw protocolError('Astrale CLI answered a malformed installation of the instance.');
+            }
+            return Object.freeze({ origin: entry.origin, url: entry.url });
+        })),
+    });
+}
+/**
+ * Why an instance listing failed, from the machine error the CLI printed on stderr (the last line
+ * that is a JSON object with an `error` code): only that code is read, never its message, since
+ * stderr may name the caller's credential. A Kernel without the listing is `unsupported`; a timeout
+ * at any phase is `timeout`; a Kernel refusal is `refused`; anything else, a command that printed
+ * no machine error and a failed read of Admin's registry (`isAdminFailure`) included, is
+ * `unavailable`.
+ */
+export function instanceRefusal(stderr) {
+    const failure = machineError(stderr);
+    if (failure === undefined) {
+        return unknown('unavailable', 'REGISTRY_CLI_FAILED');
+    }
+    const code = admittedCode(failure.error);
+    if (code === 'KERNEL_RELEASE_UNSUPPORTED')
+        return unknown('unsupported', code);
+    if (failure.phase === 'timeout')
+        return unknown('timeout', code);
+    if (code === 'RESPONSE_ERROR')
+        return unknown('refused', code);
+    return unknown('unavailable', code);
+}
+/**
+ * Whether an instance listing failed on Admin's side, not the instance's: the listing also reads
+ * Admin's registry to name what runs there, and fails as a whole when that read fails (CT24, C7).
+ * Its codes are Admin's (`REGISTRY_*`, `ADMIN_*`), never the SDK's own `REGISTRY_CLI_*`.
+ */
+export function isAdminFailure(code) {
+    return ((code.startsWith('REGISTRY_') && !code.startsWith('REGISTRY_CLI_')) || code.startsWith('ADMIN_'));
+}
+/** The instance did not answer within the probe's time. */
+export function instanceTimeout() {
+    return unknown('timeout', 'REGISTRY_CLI_TIMEOUT');
+}
+/** The CLI answered the instance listing with something this SDK cannot read. */
+export function instanceUnreadable() {
+    return unknown('unavailable', 'REGISTRY_CLI_PROTOCOL');
+}
+function unknown(reason, code) {
+    return Object.freeze({ kind: 'unknown', reason, code });
+}
+function machineError(stderr) {
+    const lines = stderr.split('\n').map((line) => line.trim());
+    for (let index = lines.length - 1; index >= 0; index -= 1) {
+        const line = lines[index];
+        if (!line.startsWith('{'))
+            continue;
+        try {
+            const value = JSON.parse(line);
+            if (isRecord(value) && typeof value.error === 'string') {
+                return { error: value.error, phase: value.phase };
+            }
+        }
+        catch {
+            // A human line that happens to start with a brace: keep looking upwards.
+        }
+    }
+    return undefined;
+}
+function protocolError(message) {
+    return new RegistryCliError('REGISTRY_CLI_PROTOCOL', message);
+}
+function admittedCode(input) {
+    return /^[A-Z][A-Z0-9_]{0,63}$/u.test(input) ? input : 'REGISTRY_CLI_FAILED';
+}
+function httpUrl(input) {
+    if (typeof input !== 'string')
+        return false;
+    try {
+        const url = new URL(input);
+        return url.protocol === 'https:' || url.protocol === 'http:';
+    }
+    catch {
+        return false;
+    }
+}
+function text(input) {
+    return typeof input === 'string' && input.length > 0;
+}
+function isRecord(input) {
+    return typeof input === 'object' && input !== null && !Array.isArray(input);
+}

package/dist/tooling/cli/registry/process.d.ts

@@ -0,0 +1,36 @@
+export interface RegistryProcessInput {
+    readonly executable: string;
+    readonly args: readonly string[];
+    readonly projectDir: string;
+    readonly signal: AbortSignal;
+    readonly timeoutMs: number;
+    /** Bytes of stdout kept before the child is stopped; a registry index can be large. */
+    readonly stdoutLimit: number;
+    /** One document written to the child's stdin, such as a publish request; none by default. */
+    readonly stdin?: string;
+    /**
+     * Bytes of stderr kept, for a caller that reads the machine error code a command without a
+     * stdout refusal document prints there (`astrale domain list -i --json`). The CLI prints that
+     * error last, after any human lines, so the last bytes are kept and older ones dropped. Absent,
+     * stderr is never kept.
+     */
+    readonly stderrLimit?: number;
+}
+export interface RegistryProcessResult {
+    readonly code: number;
+    readonly stdout: string;
+    /** The kept tail of stderr, present exactly when the input set `stderrLimit`. */
+    readonly stderr?: string;
+}
+/** The command did not end within its `timeoutMs`; the child was stopped. */
+export declare class RegistryProcessTimeoutError extends Error {
+    constructor();
+}
+/**
+ * Run one Astrale CLI registry command with bounded output and time. Stderr is drained and dropped:
+ * the CLI prints its human diagnostics there, which may name the caller's credential, and every
+ * registry command already answers with one document on stdout, its refusals included (CT29). A
+ * caller that sets `stderrLimit` gets the bounded tail back, to read a machine error code from; it
+ * never relays it.
+ */
+export declare function runRegistryProcess(input: RegistryProcessInput): Promise<RegistryProcessResult>;

package/dist/tooling/cli/registry/process.js

@@ -0,0 +1,119 @@
+import { spawn } from 'node:child_process';
+const TERMINATION_GRACE_MS = 1_000;
+/** The command did not end within its `timeoutMs`; the child was stopped. */
+export class RegistryProcessTimeoutError extends Error {
+    constructor() {
+        super('Astrale CLI command timed out.');
+        this.name = 'RegistryProcessTimeoutError';
+    }
+}
+/**
+ * Run one Astrale CLI registry command with bounded output and time. Stderr is drained and dropped:
+ * the CLI prints its human diagnostics there, which may name the caller's credential, and every
+ * registry command already answers with one document on stdout, its refusals included (CT29). A
+ * caller that sets `stderrLimit` gets the bounded tail back, to read a machine error code from; it
+ * never relays it.
+ */
+export function runRegistryProcess(input) {
+    if (input.signal.aborted)
+        return Promise.reject(interruption(input.signal));
+    return new Promise((resolve, reject) => {
+        let child;
+        try {
+            child = spawn(input.executable, [...input.args], {
+                cwd: input.projectDir,
+                stdio: ['pipe', 'pipe', 'pipe'],
+                shell: false,
+            });
+        }
+        catch (cause) {
+            reject(new Error('Astrale CLI could not be started.', { cause }));
+            return;
+        }
+        const chunks = [];
+        const errors = [];
+        let stdoutBytes = 0;
+        let stderrBytes = 0;
+        let settled = false;
+        let termination;
+        let escalation;
+        const terminate = (cause) => {
+            if (settled || termination !== undefined)
+                return;
+            termination = cause;
+            child.stdin.destroy();
+            child.kill('SIGTERM');
+            escalation = setTimeout(() => {
+                if (child.exitCode === null && child.signalCode === null)
+                    child.kill('SIGKILL');
+            }, TERMINATION_GRACE_MS);
+        };
+        const abort = () => terminate(interruption(input.signal));
+        const timeout = setTimeout(() => terminate(new RegistryProcessTimeoutError()), input.timeoutMs);
+        input.signal.addEventListener('abort', abort, { once: true });
+        const finish = () => {
+            settled = true;
+            clearTimeout(timeout);
+            if (escalation !== undefined)
+                clearTimeout(escalation);
+            input.signal.removeEventListener('abort', abort);
+        };
+        child.stdout.on('data', (chunk) => {
+            stdoutBytes += chunk.byteLength;
+            if (stdoutBytes > input.stdoutLimit) {
+                terminate(new Error('Astrale CLI stdout exceeded the supported limit.'));
+            }
+            else
+                chunks.push(chunk);
+        });
+        const stderrLimit = input.stderrLimit;
+        if (stderrLimit === undefined)
+            child.stderr.resume();
+        else {
+            // Keep the last `stderrLimit` bytes: drop whole chunks from the front once the rest covers it.
+            child.stderr.on('data', (chunk) => {
+                errors.push(chunk);
+                stderrBytes += chunk.byteLength;
+                while (errors.length > 1 && stderrBytes - errors[0].byteLength >= stderrLimit) {
+                    stderrBytes -= errors.shift().byteLength;
+                }
+            });
+        }
+        // A child that exits before reading its stdin closes the pipe; its exit code still answers.
+        child.stdin.on('error', () => undefined);
+        child.once('error', (cause) => {
+            if (settled)
+                return;
+            finish();
+            reject(termination ?? new Error('Astrale CLI could not be started.', { cause }));
+        });
+        child.once('close', (code) => {
+            if (settled)
+                return;
+            finish();
+            if (termination !== undefined) {
+                reject(termination);
+                return;
+            }
+            resolve(Object.freeze({
+                code: code ?? 1,
+                stdout: Buffer.concat(chunks).toString('utf8'),
+                ...(stderrLimit === undefined ? {} : { stderr: stderrTail(errors, stderrLimit) }),
+            }));
+        });
+        child.stdin.end(input.stdin);
+    });
+}
+/**
+ * The last `limit` bytes of stderr as text. A cut through a multi-byte character only spoils the
+ * first kept line, never the machine error the CLI prints last.
+ */
+function stderrTail(chunks, limit) {
+    const kept = Buffer.concat(chunks);
+    return kept.subarray(Math.max(0, kept.byteLength - limit)).toString('utf8');
+}
+function interruption(signal) {
+    return signal.reason instanceof Error
+        ? signal.reason
+        : new Error('Project operation interrupted.');
+}

package/dist/tooling/cli/secrets.d.ts

@@ -0,0 +1,9 @@
+import type { Runtime } from '../../application/runtime/index.js';
+import type { Adapter, LegacyAdapter } from '../../deployment/adapter/index.js';
+/**
+ * The secrets one Environment's deployment binds: the values of the secrets file its adapter
+ * declares. An Integration-free Runtime has no Providers and therefore no author-owned secrets, so
+ * its file may be absent; adapter-owned secrets, such as a signing identity, are the adapter's to
+ * resolve and never make this file required.
+ */
+export declare function environmentSecrets(adapter: Adapter<object> | LegacyAdapter<object>, parameters: object, projectDir: string, runtime: Runtime): Readonly<Record<string, string>>;

package/dist/tooling/cli/secrets.js

@@ -0,0 +1,19 @@
+import { existsSync } from 'node:fs';
+import { isAbsolute, join } from 'node:path';
+import { loadDeclaredSecrets } from './dotenv.js';
+/**
+ * The secrets one Environment's deployment binds: the values of the secrets file its adapter
+ * declares. An Integration-free Runtime has no Providers and therefore no author-owned secrets, so
+ * its file may be absent; adapter-owned secrets, such as a signing identity, are the adapter's to
+ * resolve and never make this file required.
+ */
+export function environmentSecrets(adapter, parameters, projectDir, runtime) {
+    const file = adapter.secretsFile?.(parameters);
+    if (file === undefined)
+        return Object.freeze({});
+    const path = isAbsolute(file) ? file : join(projectDir, file);
+    if (Object.keys(runtime.integrations).length === 0 && !existsSync(path)) {
+        return Object.freeze({});
+    }
+    return Object.freeze(loadDeclaredSecrets(path, file));
+}

package/dist/tooling/cli/yank.d.ts

@@ -0,0 +1,34 @@
+import type { Version } from '../../platform/versioning/index.js';
+import type { DomainRegistry } from './registry/index.js';
+/**
+ * `astrale-domain yank <version> [--undo] --json` on stdout (CT30): the yank state Admin now holds
+ * for one published version of the Project's Domain. `changed` when this call yanked or restored
+ * it, `unchanged` when it already was in that state.
+ */
+export interface YankReportV1 {
+    readonly format: 'astrale.yank-report';
+    readonly version: 1;
+    readonly origin: string;
+    readonly publication: {
+        readonly version: string;
+        readonly yanked: boolean;
+    };
+    readonly status: 'changed' | 'unchanged';
+}
+/**
+ * Yank one published version of `origin`, or restore it with `undo`, in the Admin registry. A
+ * yank only takes the version out of resolution: its installations keep running and its
+ * deployment keeps serving (tech [.72368]). Idempotent: a rerun answers `unchanged`.
+ */
+export declare function yankPublication(input: {
+    readonly origin: string;
+    readonly version: Version;
+    readonly undo: boolean;
+    readonly projectDir: string;
+    readonly signal: AbortSignal;
+}, open?: (input: {
+    readonly projectDir: string;
+    readonly signal: AbortSignal;
+}) => Promise<Pick<DomainRegistry, 'yank'>>): Promise<YankReportV1>;
+/** The one line a person reads for a report. */
+export declare function yankSummary(report: YankReportV1): string;

package/dist/tooling/cli/yank.js

@@ -0,0 +1,32 @@
+import { openDomainRegistry } from './registry/index.js';
+/**
+ * Yank one published version of `origin`, or restore it with `undo`, in the Admin registry. A
+ * yank only takes the version out of resolution: its installations keep running and its
+ * deployment keeps serving (tech [.72368]). Idempotent: a rerun answers `unchanged`.
+ */
+export async function yankPublication(input, open = openDomainRegistry) {
+    const registry = await open({ projectDir: input.projectDir, signal: input.signal });
+    const outcome = await registry.yank(input.origin, input.version, { undo: input.undo });
+    return Object.freeze({
+        format: 'astrale.yank-report',
+        version: 1,
+        origin: input.origin,
+        publication: Object.freeze({
+            version: outcome.publication.version,
+            yanked: outcome.publication.yanked,
+        }),
+        status: outcome.status,
+    });
+}
+/** The one line a person reads for a report. */
+export function yankSummary(report) {
+    const name = `${report.origin}@${report.publication.version}`;
+    if (report.publication.yanked) {
+        return report.status === 'changed'
+            ? `Yanked ${name}: line references no longer choose it; its installations and its deployment keep running.`
+            : `${name} was already yanked.`;
+    }
+    return report.status === 'changed'
+        ? `Restored ${name}: line references can choose it again.`
+        : `${name} was not yanked.`;
+}

package/dist/tooling/linter/implementations/source/callable-requirements.d.ts

@@ -10,7 +10,7 @@ export interface FunctionRequirements {
     readonly keys: ReadonlySet<string>;
     readonly indeterminate: boolean;
 }
-export declare function applicationFunctionRequirements(project: SourceProject): FunctionRequirements;
+export declare function domainFunctionRequirements(project: SourceProject): FunctionRequirements;
 export declare function requiredCallable(project: SourceProject, file: SourceFile, input: ts.Expression): Pick<RemoteCallable, 'module' | 'selector'> | undefined;
 export declare function declaredDomainDependencies(project: SourceProject): {
     readonly aliases: ReadonlyMap<string, string>;

package/dist/tooling/linter/implementations/source/callable-requirements.js

@@ -1,25 +1,25 @@
 import ts from 'typescript';
 import { objectProperty, resolveImportedSymbol, resolveProjectImport, unwrap, visit, } from '../../adapters/typescript/index.js';
 import { definitionObjects, DSL_MODULES, production, propertyExpression } from './shared.js';
-export function applicationFunctionRequirements(project) {
-    const applicationPath = project.policy.rootFiles.find(({ id }) => id === 'application')?.sourcePath;
-    const file = applicationPath && project.filesByPath.get(applicationPath);
+export function domainFunctionRequirements(project) {
+    const domainPath = project.policy.rootFiles.find(({ id }) => id === 'domain')?.sourcePath;
+    const file = domainPath && project.filesByPath.get(domainPath);
     if (!file)
         return { keys: new Set(), indeterminate: true };
-    const applications = [];
+    const definitions = [];
     visit(file.source, (node) => {
         if (!ts.isCallExpression(node))
             return;
         const symbol = resolveImportedSymbol(file, node.expression);
         if (symbol.kind === 'resolved' &&
-            symbol.name === 'defineApplication' &&
-            (symbol.module === '@astrale-os/sdk' || symbol.module === '@astrale-os/sdk/application')) {
-            applications.push(node);
+            symbol.name === 'defineDomain' &&
+            (symbol.module === '@astrale-os/sdk' || symbol.module === '@astrale-os/sdk/domain')) {
+            definitions.push(node);
         }
     });
-    if (applications.length !== 1)
+    if (definitions.length !== 1)
         return { keys: new Set(), indeterminate: true };
-    const input = applications[0].arguments[0];
+    const input = definitions[0].arguments[0];
     if (!input || !ts.isObjectLiteralExpression(unwrap(input))) {
         return { keys: new Set(), indeterminate: true };
     }
@@ -40,7 +40,7 @@ export function applicationFunctionRequirements(project) {
     if (requirementsSymbol.kind !== 'resolved' ||
         requirementsSymbol.name !== 'requirements' ||
         (requirementsSymbol.module !== '@astrale-os/sdk' &&
-            requirementsSymbol.module !== '@astrale-os/sdk/application')) {
+            requirementsSymbol.module !== '@astrale-os/sdk/domain')) {
         return { keys: new Set(), indeterminate: true };
     }
     const definition = requirementsCall.arguments[0];

package/dist/tooling/linter/implementations/source/dependencies.js

@@ -1,11 +1,11 @@
 import ts from 'typescript';
 import { propertyChain, resolveImportedSymbol, unwrap, visit, } from '../../adapters/typescript/index.js';
-import { applicationFunctionRequirements, callableReference, callableSelector, declaredDomainDependencies, remoteCallableKey, } from './callable-requirements.js';
+import { domainFunctionRequirements, callableReference, callableSelector, declaredDomainDependencies, remoteCallableKey, } from './callable-requirements.js';
 import { ambiguity, calls, isForeignDomain, production, violation } from './shared.js';
 export const dependencyRules = [
     {
         id: 'FNC-XDOM-DECLARED',
-        ruleRevision: '269e22202a0fbec5ec4afc3579ca504eed457f44046b99e64a38d08634294909',
+        ruleRevision: '72f960f87ac682695ea495925e31d15b9bd640b25d90ac1dcc6a1329a0be51b0',
         evaluate(project) {
             const evidence = [];
             for (const file of production(project, 'functions')) {
@@ -19,15 +19,15 @@ export const dependencyRules = [
     },
     {
         id: 'FNC-XDOM-REQ',
-        ruleRevision: 'a646c9931bb8b5a011a2cf7431f362fcb0e63be49dfc4c1bc0eba77a8aca8fdb',
+        ruleRevision: 'a4666ebb09b2027983edc2ffc6411692ade9877ee9c4f23c4b0a8d157a0cf385',
         evaluate(project) {
             const { targets, evidence } = observeInvocations(project);
-            const declared = applicationFunctionRequirements(project);
+            const declared = domainFunctionRequirements(project);
             const results = evidence.filter(({ kind }) => kind === 'ambiguity');
             for (const target of targets) {
                 if (declared.keys.has(remoteCallableKey(target)))
                     continue;
-                results.push((declared.indeterminate ? ambiguity : violation)(target.file, target.node, `Remote Domain callable ${target.module} ${target.selector.join('.')} lacks one provable exact Application Function requirement.`));
+                results.push((declared.indeterminate ? ambiguity : violation)(target.file, target.node, `Remote Domain callable ${target.module} ${target.selector.join('.')} lacks one provable exact Domain Function requirement.`));
             }
             return results;
         },
@@ -70,16 +70,18 @@ function observeInvocations(project) {
                 let alias;
                 let selector;
                 if (path[0] === 'dependencies') {
-                    if (path.length !== 4 || !['caller', 'self', 'union'].includes(path[2])) {
-                        evidence.push(violation(file, node, 'Dependency invocation requires one direct alias and one explicit caller, self, or union authority.'));
+                    if (path.length !== 4 || !['caller', 'self'].includes(path[2])) {
+                        evidence.push(violation(file, node, 'Dependency invocation requires one direct alias and one explicit caller or self authority.'));
                         return;
                     }
                     alias = path[1];
                     selector = selectedCallable(node.arguments[0]);
                 }
-                else if (path[0] === 'kernel' &&
-                    (path.length === 2 ||
-                        (path.length === 3 && ['caller', 'self', 'union'].includes(path[1])))) {
+                else if (path[0] === 'kernel') {
+                    if (path.length !== 2 && (path.length !== 3 || !['caller', 'self'].includes(path[1]))) {
+                        evidence.push(violation(file, node, 'Kernel invocation requires the default, caller, or self authority.'));
+                        return;
+                    }
                     const argument = node.arguments[0];
                     if (!argument) {
                         evidence.push(violation(file, node, 'Kernel invocation requires one canonical typed reference.'));

package/dist/tooling/linter/implementations/source/global.js

@@ -887,7 +887,7 @@ function isDomainDefinitionCall(file, call) {
     const expression = unwrap(call.expression);
     const direct = importedSymbol(file, expression);
     if (direct?.module.startsWith('@astrale-os/sdk') &&
-        (direct.name === 'defineApplication' ||
+        (direct.name === 'defineDomain' ||
             direct.name === 'defineFrontend' ||
             direct.name === 'defineRuntime' ||
             direct.name === 'requirements')) {

package/dist/tooling/linter/implementations/source/mutations.js

@@ -8,7 +8,7 @@ const FORBIDDEN_CALLS = new Set(['invoke', 'query', 'retry', 'run', 'submit']);
 export const mutationRules = [
     {
         id: 'MUT-PLAN-REQ',
-        ruleRevision: '9201a4e5799f62cc8df37d281d1f02516132632e33b4a82187c399780bdfe340',
+        ruleRevision: '73f37ffa6b2fa4a1f236749696404d6b1fb399f1ea0e3947d8ac4df7073b3ceb',
         evaluate(project) {
             const evidence = [];
             const targets = [];
@@ -30,7 +30,7 @@ export const mutationRules = [
                         targets.push({ file, node: selectedClass, ...target, operation: classOperation });
                     }
                     else if (selectedClass && expressionSelectsDependency(selectedClass)) {
-                        evidence.push(ambiguity(file, selectedClass, 'Mutation plan selects a foreign Class dynamically, so its Application requirement cannot be proven.'));
+                        evidence.push(ambiguity(file, selectedClass, 'Mutation plan selects a foreign Class dynamically, so its Domain requirement cannot be proven.'));
                     }
                 });
             }
@@ -46,21 +46,21 @@ export const mutationRules = [
             }
             if (targets.length === 0 && identityCalls.length === 0)
                 return evidence;
-            const requirements = applicationPlanRequirements(project);
+            const requirements = domainPlanRequirements(project);
             for (const target of targets) {
                 const key = classRequirementKey(target.dependency, target.className, target.operation);
                 if (requirements.classes.has(key))
                     continue;
                 evidence.push(requirements.indeterminate
-                    ? ambiguity(target.file, target.node, `Application Class requirements are opaque for dependency ${target.dependency} Class ${target.className}.`)
-                    : violation(target.file, target.node, `Mutation plan dependency ${target.dependency} Class ${target.className} lacks Application ${target.operation} authority.`));
+                    ? ambiguity(target.file, target.node, `Domain Class requirements are opaque for dependency ${target.dependency} Class ${target.className}.`)
+                    : violation(target.file, target.node, `Mutation plan dependency ${target.dependency} Class ${target.className} lacks Domain ${target.operation} authority.`));
             }
             for (const invocation of identityCalls) {
                 if (!requirements.functions.has(invocation.syscall)) {
                     const name = invocation.syscall === 'register' ? 'Register' : 'Provision';
                     evidence.push(requirements.indeterminate
-                        ? ambiguity(invocation.file, invocation.node, `Application Function requirements are opaque for Kernel ${name}.`)
-                        : violation(invocation.file, invocation.node, `Kernel ${name} invocation lacks the exact Application Function requirement.`));
+                        ? ambiguity(invocation.file, invocation.node, `Domain Function requirements are opaque for Kernel ${name}.`)
+                        : violation(invocation.file, invocation.node, `Kernel ${name} invocation lacks the exact Domain Function requirement.`));
                 }
             }
             return evidence;
@@ -748,24 +748,24 @@ function parameterProperty(use, sourceName) {
     const property = element.propertyName ?? element.name;
     return (ts.isIdentifier(property) || ts.isStringLiteral(property)) && property.text === sourceName;
 }
-function applicationPlanRequirements(project) {
-    const applicationPath = project.policy.rootFiles.find(({ id }) => id === 'application')?.sourcePath;
-    const file = applicationPath && project.filesByPath.get(applicationPath);
+function domainPlanRequirements(project) {
+    const domainPath = project.policy.rootFiles.find(({ id }) => id === 'domain')?.sourcePath;
+    const file = domainPath && project.filesByPath.get(domainPath);
     if (!file)
         return emptyPlanRequirements(true);
-    const applications = [];
+    const definitions = [];
     visit(file.source, (node) => {
         if (!ts.isCallExpression(node))
             return;
         const symbol = importedSymbol(file, node.expression);
-        if (symbol?.name === 'defineApplication' &&
-            (symbol.module === '@astrale-os/sdk' || symbol.module === '@astrale-os/sdk/application')) {
-            applications.push(node);
+        if (symbol?.name === 'defineDomain' &&
+            (symbol.module === '@astrale-os/sdk' || symbol.module === '@astrale-os/sdk/domain')) {
+            definitions.push(node);
         }
     });
-    if (applications.length !== 1)
+    if (definitions.length !== 1)
         return emptyPlanRequirements(true);
-    const input = staticObject(applications[0].arguments[0]);
+    const input = staticObject(definitions[0].arguments[0]);
     const requirementValue = input && assignedValue(input, 'requirements');
     if (requirementValue === undefined)
         return emptyPlanRequirements(false);
@@ -774,7 +774,7 @@ function applicationPlanRequirements(project) {
     if (!requirementCall ||
         requirementSymbol?.name !== 'requirements' ||
         (requirementSymbol.module !== '@astrale-os/sdk' &&
-            requirementSymbol.module !== '@astrale-os/sdk/application')) {
+            requirementSymbol.module !== '@astrale-os/sdk/domain')) {
         return emptyPlanRequirements(true);
     }
     const definition = staticObject(requirementCall.arguments[0]);

package/dist/tooling/linter/implementations/source/providers.js

@@ -1,6 +1,6 @@
 import ts from 'typescript';
 import { propertyChain, resolveImportedSymbol, resolveProjectImport, unwrap, visit, } from '../../adapters/typescript/index.js';
-import { applicationFunctionRequirements, callableReference, callableSelector, externalFacade, lexicalConstInitializer, remoteCallableKey, } from './callable-requirements.js';
+import { domainFunctionRequirements, callableReference, callableSelector, externalFacade, lexicalConstInitializer, remoteCallableKey, } from './callable-requirements.js';
 import { ambiguity, production, violation } from './shared.js';
 const LOCAL_DOMAIN_LAYERS = new Set([
     'functions',
@@ -54,7 +54,7 @@ export const providerRules = [
     },
     {
         id: 'PRV-XDOM-REQ',
-        ruleRevision: '065816fda57910e917670ed657cf45b1ad3bfdc8fba6362f48123221725e20a0',
+        ruleRevision: 'b3fc6c409374b924b1b06c17f6d3702ec9d1e9e7a286bd955a151d0bf12c5b24',
         evaluate(project) {
             const targets = [];
             const evidence = [];
@@ -71,14 +71,14 @@ export const providerRules = [
             }
             if (targets.length === 0)
                 return evidence;
-            const declared = applicationFunctionRequirements(project);
+            const declared = domainFunctionRequirements(project);
             for (const target of targets) {
                 if (declared.keys.has(remoteCallableKey(target)))
                     continue;
                 const selector = target.selector.join('.');
                 evidence.push(declared.indeterminate
-                    ? ambiguity(target.file, target.node, `Application Function requirements are opaque for ${target.module} ${selector}.`)
-                    : violation(target.file, target.node, `Remote Domain callable ${target.module} ${selector} lacks one exact Application Function requirement.`));
+                    ? ambiguity(target.file, target.node, `Domain Function requirements are opaque for ${target.module} ${selector}.`)
+                    : violation(target.file, target.node, `Remote Domain callable ${target.module} ${selector} lacks one exact Domain Function requirement.`));
             }
             return evidence;
         },

package/dist/tooling/linter/implementations/source/views.js

@@ -11,7 +11,7 @@ const DECLARATIONS = [
 ];
 const FRONTEND_MODULES = new Set([
     '@astrale-os/sdk',
-    '@astrale-os/sdk/application',
+    '@astrale-os/sdk/domain',
     '@astrale-os/sdk/view',
 ]);
 export const viewRules = [
@@ -48,7 +48,7 @@ export const viewRules = [
                         evidence.push(uncertain);
                         continue;
                     }
-                    evidence.push(violation(file, definition.call, 'Views composes an SDK frontend; move defineFrontend beside defineApplication in application.ts.'));
+                    evidence.push(violation(file, definition.call, 'Views composes an SDK frontend; move defineFrontend beside defineDomain in domain.ts.'));
                 }
             }
             return evidence;