@astrale-os/sdk 0.5.0-beta.99 → 0.6.0-beta.0

package/dist/tooling/cli/astrale/instance.js

@@ -0,0 +1,52 @@
+import { astraleFailure } from './failure.js';
+import { runAstrale } from './process.js';
+/** Resolve and probe a bookmark through the pinned CLI, preserving its TLS trust. */
+export async function resolveAstraleInstanceIssuer(input, dependencies = { run: runAstrale }) {
+    const result = await dependencies.run({
+        executable: input.executable,
+        projectDir: input.projectDir,
+        signal: input.signal,
+        timeoutMs: 30_000,
+        args: ['--ci', '--no-prompt', 'instance', 'status', input.instance, '--bookmarked', '--json'],
+    });
+    if (result.code !== 0)
+        throw astraleFailure('instance status', result);
+    let value;
+    try {
+        value = JSON.parse(result.stdout);
+    }
+    catch {
+        throw new TypeError('Astrale instance status did not return one JSON value.');
+    }
+    if (value === null ||
+        typeof value !== 'object' ||
+        Array.isArray(value) ||
+        !('kind' in value) ||
+        value.kind !== 'bookmark' ||
+        !('state' in value) ||
+        value.state !== 'ready' ||
+        !('issuer' in value) ||
+        typeof value.issuer !== 'string') {
+        throw new TypeError('Astrale instance status returned invalid Kernel identity evidence.');
+    }
+    let issuer;
+    try {
+        issuer = new URL(value.issuer);
+    }
+    catch {
+        throw new TypeError('Astrale instance status returned an invalid Kernel issuer.');
+    }
+    if (!['https:', 'http:'].includes(issuer.protocol) ||
+        issuer.username ||
+        issuer.password ||
+        issuer.search ||
+        issuer.hash) {
+        throw new TypeError('Astrale instance status returned an invalid Kernel issuer.');
+    }
+    // Child Kernels share an origin, but their path-qualified identities remain distinct.
+    const canonical = issuer.href.replace(/\/$/u, '');
+    if (input.expectedIssuer !== undefined && canonical !== input.expectedIssuer) {
+        throw new Error('Installation bookmark changed Kernel; restart pnpm dev to apply it.');
+    }
+    return canonical;
+}

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

@@ -0,0 +1,13 @@
+export interface AstraleProcessResult {
+    readonly code: number;
+    readonly stdout: string;
+    readonly stderr: string;
+}
+/** Run one exact Kernel CLI executable with bounded output, time, and termination. */
+export declare function runAstrale(input: {
+    readonly executable: string;
+    readonly args: readonly string[];
+    readonly projectDir: string;
+    readonly signal: AbortSignal;
+    readonly timeoutMs: number;
+}): Promise<AstraleProcessResult>;

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

@@ -0,0 +1,94 @@
+import { spawn } from 'node:child_process';
+const OUTPUT_LIMIT = 256 * 1024;
+const TERMINATION_GRACE_MS = 1_000;
+/** Run one exact Kernel CLI executable with bounded output, time, and termination. */
+export function runAstrale(input) {
+    if (input.signal.aborted)
+        return Promise.reject(abortError(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,
+                // This owner already forwards cancellation and enforces a deadline. Keep
+                // terminal group signals from killing installation observation/View cleanup.
+                detached: process.platform !== 'win32',
+            });
+            child.stdin.end();
+        }
+        catch (cause) {
+            reject(new Error('Astrale CLI is unavailable.', { cause }));
+            return;
+        }
+        let stdout = '';
+        let stderr = '';
+        let stdoutBytes = 0;
+        let stderrBytes = 0;
+        let settled = false;
+        let termination;
+        let escalation;
+        const abort = () => terminate(input.signal.reason instanceof Error
+            ? input.signal.reason
+            : new Error('Project operation interrupted.'));
+        input.signal.addEventListener('abort', abort, { once: true });
+        const cleanup = () => {
+            clearTimeout(timeout);
+            if (escalation !== undefined)
+                clearTimeout(escalation);
+            input.signal.removeEventListener('abort', abort);
+        };
+        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 timeout = setTimeout(() => terminate(new Error('Astrale CLI command timed out.')), input.timeoutMs);
+        child.stdout.on('data', (chunk) => {
+            stdoutBytes += chunk.byteLength;
+            if (stdoutBytes > OUTPUT_LIMIT) {
+                terminate(new Error('Astrale CLI stdout exceeded the supported limit.'));
+            }
+            else
+                stdout += chunk.toString('utf8');
+        });
+        child.stderr.on('data', (chunk) => {
+            stderrBytes += chunk.byteLength;
+            if (stderrBytes > OUTPUT_LIMIT) {
+                terminate(new Error('Astrale CLI stderr exceeded the supported limit.'));
+            }
+            else
+                stderr += chunk.toString('utf8');
+        });
+        child.once('error', (cause) => {
+            if (settled)
+                return;
+            settled = true;
+            cleanup();
+            reject(new Error('Astrale CLI could not be started.', { cause }));
+        });
+        child.once('close', (code) => {
+            if (settled)
+                return;
+            settled = true;
+            cleanup();
+            if (termination !== undefined) {
+                reject(termination);
+                return;
+            }
+            resolve(Object.freeze({ code: code ?? 1, stdout, stderr }));
+        });
+    });
+}
+function abortError(signal) {
+    return signal.reason instanceof Error
+        ? signal.reason
+        : new Error('Project operation interrupted.');
+}

package/dist/tooling/cli/astrale/version.d.ts

@@ -0,0 +1,18 @@
+import type { AstraleProcessResult } from './process.js';
+import { resolveAstraleExecutable } from './executable.js';
+export declare const MINIMUM_KERNEL_CLI_VERSION = "1.0.0-beta.48";
+export interface CompatibleAstraleDependencies {
+    readonly resolveExecutable: typeof resolveAstraleExecutable;
+    readonly run: (input: {
+        readonly executable: string;
+        readonly args: readonly string[];
+        readonly projectDir: string;
+        readonly signal: AbortSignal;
+        readonly timeoutMs: number;
+    }) => Promise<AstraleProcessResult>;
+}
+/** Pin and admit one compatible CLI before any configured Kernel installation effect. */
+export declare function resolveCompatibleAstrale(input: {
+    readonly projectDir: string;
+    readonly signal: AbortSignal;
+}, dependencies?: CompatibleAstraleDependencies): Promise<string>;

package/dist/tooling/cli/astrale/version.js

@@ -0,0 +1,55 @@
+import { resolveAstraleExecutable } from './executable.js';
+import { astraleFailure } from './failure.js';
+import { runAstrale } from './process.js';
+export const MINIMUM_KERNEL_CLI_VERSION = '1.0.0-beta.48';
+/** Pin and admit one compatible CLI before any configured Kernel installation effect. */
+export async function resolveCompatibleAstrale(input, dependencies = {
+    resolveExecutable: resolveAstraleExecutable,
+    run: runAstrale,
+}) {
+    const executable = await dependencies.resolveExecutable();
+    const result = await dependencies.run({
+        executable,
+        projectDir: input.projectDir,
+        args: ['--version'],
+        signal: input.signal,
+        timeoutMs: 10_000,
+    });
+    if (result.code !== 0)
+        throw astraleFailure('version', result);
+    const version = result.stdout.trim().replace(/^v/u, '');
+    if (!isCompatible(version)) {
+        const diagnostic = semver(version) === undefined ? '<invalid>' : version;
+        throw new TypeError(`Astrale CLI ${diagnostic} is incompatible; ${MINIMUM_KERNEL_CLI_VERSION} or newer is required.`);
+    }
+    return executable;
+}
+function isCompatible(input) {
+    const value = semver(input);
+    const minimum = semver(MINIMUM_KERNEL_CLI_VERSION);
+    if (value === undefined)
+        return false;
+    for (let index = 0; index < 3; index += 1) {
+        if (value.core[index] > minimum.core[index])
+            return true;
+        if (value.core[index] < minimum.core[index])
+            return false;
+    }
+    if (value.prerelease === undefined)
+        return true;
+    if (minimum.prerelease === undefined)
+        return false;
+    if (value.prerelease.name !== minimum.prerelease.name) {
+        return value.prerelease.name.localeCompare(minimum.prerelease.name) > 0;
+    }
+    return value.prerelease.number >= minimum.prerelease.number;
+}
+function semver(input) {
+    const match = /^(\d+)\.(\d+)\.(\d+)(?:-([a-z]+)\.(\d+))?$/u.exec(input);
+    if (match === null)
+        return undefined;
+    return {
+        core: [Number(match[1]), Number(match[2]), Number(match[3])],
+        ...(match[4] === undefined ? {} : { prerelease: { name: match[4], number: Number(match[5]) } }),
+    };
+}

package/dist/tooling/cli/bun.js

@@ -2,7 +2,7 @@ import { spawn } from 'node:child_process';
 import { lstatSync, readFileSync, realpathSync, statSync } from 'node:fs';
 import { createRequire } from 'node:module';
 import { dirname, isAbsolute, join, relative, resolve } from 'node:path';
-const FORWARDED_SIGNALS = ['SIGINT', 'SIGTERM'];
+const FORWARDED_SIGNALS = ['SIGINT', 'SIGTERM', 'SIGHUP'];
 export class BunRequiredError extends Error {
     constructor(options) {
         super('astrale-domain requires Bun to import astrale.config.ts and its Runtime module.', options);

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

@@ -0,0 +1,2 @@
+/** Admit one caller-owned credential without retaining its value outside this command. */
+export declare function loadPrivateCredentialFile(path: string, platform?: NodeJS.Platform): string;

package/dist/tooling/cli/credential.js

@@ -0,0 +1,57 @@
+import { closeSync, constants, fstatSync, openSync, readSync } from 'node:fs';
+const MAXIMUM_CREDENTIAL_BYTES = 64 * 1024;
+/** Admit one caller-owned credential without retaining its value outside this command. */
+export function loadPrivateCredentialFile(path, platform = process.platform) {
+    if (platform === 'win32') {
+        throw new Error('--credential-file is unavailable on Windows until private no-reparse file admission is supported.');
+    }
+    let descriptor;
+    try {
+        descriptor = openSync(path, constants.O_RDONLY | constants.O_NOFOLLOW);
+    }
+    catch (cause) {
+        if (errorCode(cause) === 'ENOENT') {
+            throw new Error(`Credential file '${path}' is missing.`, { cause });
+        }
+        if (errorCode(cause) === 'ELOOP') {
+            throw new Error(`Credential file '${path}' must be a regular file and not a symlink.`, {
+                cause,
+            });
+        }
+        throw cause;
+    }
+    try {
+        const info = fstatSync(descriptor);
+        if (!info.isFile())
+            throw new Error(`Credential file '${path}' must be a regular file.`);
+        if ((info.mode & 0o077) !== 0) {
+            throw new Error(`Credential file '${path}' must not be accessible by group or other users.`);
+        }
+        if (info.size === 0 || info.size > MAXIMUM_CREDENTIAL_BYTES) {
+            throw new Error(`Credential file '${path}' must contain one bounded credential.`);
+        }
+        const bytes = Buffer.allocUnsafe(info.size + 1);
+        let offset = 0;
+        while (offset < bytes.length) {
+            const read = readSync(descriptor, bytes, offset, bytes.length - offset, null);
+            if (read === 0)
+                break;
+            offset += read;
+        }
+        if (offset !== info.size)
+            throw new Error(`Credential file '${path}' changed while read.`);
+        const credential = bytes.subarray(0, offset).toString('utf8').trim();
+        if (credential.length === 0 || /[\r\n\0]/u.test(credential)) {
+            throw new Error(`Credential file '${path}' must contain exactly one credential.`);
+        }
+        return credential;
+    }
+    finally {
+        closeSync(descriptor);
+    }
+}
+function errorCode(input) {
+    return input !== null && typeof input === 'object' && 'code' in input
+        ? String(Reflect.get(input, 'code'))
+        : undefined;
+}

package/dist/tooling/cli/development/candidate.d.ts

@@ -0,0 +1,25 @@
+import type { Adapter, InstallationTarget, PreparedArtifact } from '../../../deployment/adapter/index.js';
+export interface DevelopmentCandidate {
+    readonly adapter: Adapter<object>;
+    readonly parameters: object;
+    readonly installation?: InstallationTarget;
+    readonly artifact: PreparedArtifact;
+    readonly secrets: Readonly<Record<string, string>>;
+    readonly sources: ReadonlySet<string>;
+}
+/** Rebuild one complete, isolated Environment candidate from authored sources. */
+export declare class DevelopmentCandidateBuilder {
+    #private;
+    constructor(input: {
+        readonly configPath: string;
+        readonly projectDir: string;
+        readonly environment: string;
+        readonly runtimePath: string;
+        readonly overrideSecrets?: Readonly<Record<string, string>>;
+    });
+    prepare(signal: AbortSignal): Promise<DevelopmentCandidate>;
+}
+export declare function discoverRuntimePath(configPath: string): Promise<string>;
+export declare function sameEnvironment(current: DevelopmentCandidate, candidate: DevelopmentCandidate): boolean;
+/** Identify a rebuilt candidate that cannot change provider or installation state. */
+export declare function sameDeploymentCandidate(current: DevelopmentCandidate, candidate: DevelopmentCandidate): boolean;

package/dist/tooling/cli/development/candidate.js

@@ -0,0 +1,176 @@
+import { existsSync } from 'node:fs';
+import { mkdir, rm, writeFile } from 'node:fs/promises';
+import { dirname, isAbsolute, join, relative, resolve, sep } from 'node:path';
+import { pathToFileURL } from 'node:url';
+import { admitRuntime, compile, resolveRuntime, runtime, verifyPreflight, } from '../../../deployment/index.js';
+import { admitProjectModule } from '../../../project/index.js';
+import { loadDeclaredSecrets } from '../dotenv.js';
+import { selectEnvironment } from '../project.js';
+import { projectImportPlugin } from './project-imports.js';
+import { DevelopmentSources } from './sources.js';
+/** Rebuild one complete, isolated Environment candidate from authored sources. */
+export class DevelopmentCandidateBuilder {
+    #configPath;
+    #projectDir;
+    #environment;
+    #runtimePath;
+    #overrideSecrets;
+    #generation = 0;
+    constructor(input) {
+        this.#configPath = input.configPath;
+        this.#projectDir = input.projectDir;
+        this.#environment = input.environment;
+        this.#runtimePath = input.runtimePath;
+        this.#overrideSecrets = input.overrideSecrets;
+    }
+    async prepare(signal) {
+        throwIfAborted(signal);
+        const directory = join(this.#projectDir, '.astrale', 'development', this.#environment, 'source', String(++this.#generation));
+        await mkdir(directory, { recursive: true });
+        const bridge = join(directory, 'bridge.ts');
+        const sources = new DevelopmentSources(this.#projectDir);
+        sources.record(join(this.#projectDir, 'package.json'));
+        const configImport = moduleSpecifier(dirname(bridge), this.#configPath);
+        const runtimeImport = moduleSpecifier(dirname(bridge), resolve(dirname(this.#configPath), this.#runtimePath));
+        await writeFile(bridge, `export { default as project } from ${JSON.stringify(configImport)}\n` +
+            `export { default as runtime } from ${JSON.stringify(runtimeImport)}\n`);
+        try {
+            const bunRuntime = bun();
+            const built = await bunRuntime.build({
+                entrypoints: [bridge],
+                outdir: directory,
+                naming: 'application.mjs',
+                target: 'bun',
+                format: 'esm',
+                packages: 'bundle',
+                plugins: [projectImportPlugin(this.#projectDir, bunRuntime)],
+                splitting: false,
+                sourcemap: 'inline',
+                metafile: true,
+                throw: false,
+            });
+            throwIfAborted(signal);
+            if (!built.success) {
+                const diagnostics = built.logs.map(({ message, position }) => position === undefined || position === null
+                    ? message
+                    : `${relative(this.#projectDir, position.file)}:${position.line}:${position.column}: ${message}`);
+                throw new Error(['Authored Application rebuild failed.', ...diagnostics].join('\n'));
+            }
+            const output = built.outputs.find((candidate) => candidate.path.endsWith('application.mjs'));
+            if (output === undefined)
+                throw new Error('Authored Application rebuild produced no module.');
+            const loaded = (await import(`${pathToFileURL(output.path).href}?development=${this.#generation}`));
+            if (Object.keys(loaded).some((key) => key !== 'project' && key !== 'runtime')) {
+                throw new TypeError('Development bridge produced unexpected exports.');
+            }
+            const project = admitProjectModule({ default: loaded.project });
+            if ((project.entrypoints?.runtime ?? './runtime.ts') !== this.#runtimePath) {
+                throw new Error('Runtime entrypoint changed; restart pnpm dev to apply it.');
+            }
+            const environment = selectEnvironment(project, this.#environment);
+            const resolved = await resolveRuntime(runtime(this.#runtimePath), async (path) => {
+                if (path !== this.#runtimePath) {
+                    throw new Error('Runtime entrypoint changed; restart pnpm dev to apply it.');
+                }
+                return Object.freeze({ default: loaded.runtime });
+            });
+            const build = compile(project.application);
+            admitRuntime({ runtime: build.runtime }, resolved);
+            const adapter = environment.deployment.adapter;
+            const parameters = environment.deployment.parameters;
+            for (const path of Object.keys(built.metafile?.inputs ?? {}))
+                sources.record(path);
+            const source = await adapter.prepare(parameters, {
+                projectDir: this.#projectDir,
+                environment: this.#environment,
+                ...(environment.installation === undefined
+                    ? {}
+                    : { installation: environment.installation }),
+                mode: 'release',
+                recordSource: sources.record,
+                signal,
+                build,
+                runtime: resolved,
+            });
+            const artifact = verifyPreflight({ build, runtime: resolved, source });
+            const declared = this.#overrideSecrets === undefined
+                ? secretsFor(adapter, parameters, this.#projectDir, resolved.runtime)
+                : { values: this.#overrideSecrets };
+            if (declared.path !== undefined)
+                sources.record(declared.path);
+            return Object.freeze({
+                adapter,
+                parameters,
+                ...(environment.installation === undefined
+                    ? {}
+                    : { installation: environment.installation }),
+                artifact,
+                secrets: declared.values,
+                sources: sources.snapshot(),
+            });
+        }
+        finally {
+            await rm(directory, { recursive: true, force: true });
+        }
+    }
+}
+export async function discoverRuntimePath(configPath) {
+    const loaded = (await import(`${pathToFileURL(configPath).href}?discover=${Date.now()}`));
+    const project = admitProjectModule(loaded);
+    return project.entrypoints?.runtime ?? './runtime.ts';
+}
+export function sameEnvironment(current, candidate) {
+    return (candidate.adapter.name === current.adapter.name &&
+        candidate.adapter.version === current.adapter.version &&
+        candidate.artifact.build.schema.compiled.root.origin ===
+            current.artifact.build.schema.compiled.root.origin &&
+        stable(candidate.parameters) === stable(current.parameters) &&
+        stable(candidate.installation) === stable(current.installation));
+}
+/** Identify a rebuilt candidate that cannot change provider or installation state. */
+export function sameDeploymentCandidate(current, candidate) {
+    return (sameEnvironment(current, candidate) &&
+        candidate.artifact.build.schema.compiled.root.revision ===
+            current.artifact.build.schema.compiled.root.revision &&
+        candidate.artifact.digest === current.artifact.digest &&
+        stable(candidate.secrets) === stable(current.secrets));
+}
+function secretsFor(adapter, parameters, projectDir, selectedRuntime) {
+    const file = adapter.secretsFile?.(parameters);
+    if (file === undefined)
+        return { values: Object.freeze({}) };
+    const path = isAbsolute(file) ? file : join(projectDir, file);
+    if (Object.keys(selectedRuntime.integrations).length === 0 && !existsSync(path)) {
+        return { values: Object.freeze({}) };
+    }
+    return { values: Object.freeze(loadDeclaredSecrets(path, file)), path };
+}
+function bun() {
+    const value = Reflect.get(globalThis, 'Bun');
+    if (value === undefined || typeof value.build !== 'function') {
+        throw new TypeError('Domain development requires the Bun runtime.');
+    }
+    return value;
+}
+function moduleSpecifier(from, target) {
+    const path = relative(from, target).split(sep).join('/');
+    return path.startsWith('.') ? path : `./${path}`;
+}
+function stable(input) {
+    if (input === undefined)
+        return 'undefined';
+    if (input === null || typeof input !== 'object')
+        return JSON.stringify(input);
+    if (Array.isArray(input))
+        return `[${input.map(stable).join(',')}]`;
+    const record = input;
+    return `{${Object.keys(record)
+        .sort()
+        .map((key) => `${JSON.stringify(key)}:${stable(record[key])}`)
+        .join(',')}}`;
+}
+function throwIfAborted(signal) {
+    if (signal.aborted) {
+        throw signal.reason instanceof Error ? signal.reason : new Error('Development interrupted.');
+    }
+}

package/dist/tooling/cli/development/deployment.d.ts

@@ -0,0 +1,16 @@
+import type { ReadyDeployResult } from '../../../deployment/adapter/index.js';
+import type { InstallationEvidence } from '../installation/index.js';
+import type { DevelopmentCandidate } from './candidate.js';
+export interface DevelopmentDeploymentInput {
+    readonly projectDir: string;
+    readonly environment: string;
+    readonly deployOnly: boolean;
+    readonly identity?: string;
+    readonly credential?: string;
+    readonly installationExecutable?: string;
+}
+/** Commit and verify one complete remote candidate, then reconcile its optional installation. */
+export declare function deployDevelopmentCandidate(candidate: DevelopmentCandidate, input: DevelopmentDeploymentInput, signal: AbortSignal): Promise<{
+    readonly deployment: ReadyDeployResult;
+    readonly installation?: InstallationEvidence;
+}>;

package/dist/tooling/cli/development/deployment.js

@@ -0,0 +1,39 @@
+import { verifyDeployment } from '../../../deployment/index.js';
+import { reconcileEnvironmentRelease } from '../environment-release.js';
+/** Commit and verify one complete remote candidate, then reconcile its optional installation. */
+export async function deployDevelopmentCandidate(candidate, input, signal) {
+    const deployed = await candidate.adapter.deploy(candidate.parameters, {
+        projectDir: input.projectDir,
+        environment: input.environment,
+        ...(candidate.installation === undefined ? {} : { installation: candidate.installation }),
+        ...(input.identity === undefined ? {} : { identity: input.identity }),
+        ...(input.credential === undefined ? {} : { credential: input.credential }),
+        secrets: candidate.secrets,
+        artifact: candidate.artifact,
+        signal,
+    });
+    const verified = verifyDeployment(candidate.artifact, deployed);
+    if (verified.status === 'failed') {
+        throw new Error(`Deployment failed during ${verified.phase}: ${verified.error.message}`, {
+            cause: verified.error,
+        });
+    }
+    const installation = await reconcileEnvironmentRelease({
+        projectDir: input.projectDir,
+        environment: input.environment,
+        adapter: candidate.adapter,
+        deployment: verified,
+        ...(candidate.installation === undefined ? {} : { installation: candidate.installation }),
+        deployOnly: input.deployOnly,
+        ...(input.installationExecutable === undefined
+            ? {}
+            : { installationExecutable: input.installationExecutable }),
+        ...(input.identity === undefined ? {} : { identity: input.identity }),
+        ...(input.credential === undefined ? {} : { credential: input.credential }),
+        signal,
+    });
+    return Object.freeze({
+        deployment: verified,
+        ...(installation === undefined ? {} : { installation }),
+    });
+}

package/dist/tooling/cli/development/develop.d.ts

@@ -1,10 +1,11 @@
-import type { DevelopmentOverrides } from '../../../deployment/adapter/index.js';
-/** Run one complete provider-neutral development session until interruption. */
+/** Watch one Project Environment and serialize complete remote deployment generations. */
 export declare function develop(input: {
     readonly configPath: string;
     readonly projectDir: string;
     readonly environment: string;
-    readonly overrides: DevelopmentOverrides;
+    readonly deployOnly: boolean;
+    readonly identity?: string;
+    readonly credentialFile?: string;
     readonly sessionFile?: string;
     readonly secretsFile?: string;
 }): Promise<number>;