@astrale-os/sdk 0.6.0-beta.4 → 0.6.0-beta.41

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 } 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>, 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/adapters/typescript/imports.d.ts

@@ -3,4 +3,3 @@ import type { SourceProject, SourceDependencyIssue, SourceFile, SourceImport } f
 export declare function collectImports(source: ts.SourceFile): SourceImport[];
 export declare function collectDependencyIssues(source: ts.SourceFile): SourceDependencyIssue[];
 export declare function resolveProjectImport(project: SourceProject, importer: SourceFile, specifier: string): SourceFile | undefined;
-export declare function isWithin(directory: string, path: string): boolean;

package/dist/tooling/linter/adapters/typescript/imports.js

@@ -1,4 +1,4 @@
-import { dirname, extname, isAbsolute, join, relative, resolve } from 'node:path';
+import { dirname, extname, join, relative, resolve } from 'node:path';
 import ts from 'typescript';
 import { isLocallyDeclared } from './syntax.js';
 export function collectImports(source) {
@@ -166,7 +166,3 @@ function visit(node, callback) {
     callback(node);
     node.forEachChild((child) => visit(child, callback));
 }
-export function isWithin(directory, path) {
-    const child = relative(directory, path);
-    return child === '' || (!child.startsWith('..') && !isAbsolute(child));
-}

package/dist/tooling/linter/adapters/typescript/index.d.ts

@@ -1,7 +1,7 @@
 export { discoverProject } from './discover.js';
 export { sourceEvidenceAdmission } from './evidence-admission.js';
 export { collectDependencyIssues, resolveProjectImport } from './imports.js';
-export { importedSymbol, isLocallyDeclared, resolveImportedSymbol, location, objectProperty, propertyChain, staticText, unwrap, visit, } from './syntax.js';
+export { bindingContains, importedSymbol, isLocallyDeclared, resolveImportedSymbol, location, objectProperty, propertyChain, staticText, unwrap, visit, visitOwnBody, } from './syntax.js';
 export { assertSingleTypeUniverse } from './type-universe.js';
 export { observeQueryDefinitions } from './query-observation.js';
 export { queryCollectionKind } from './query-collection-type.js';

package/dist/tooling/linter/adapters/typescript/index.js

@@ -1,7 +1,7 @@
 export { discoverProject } from './discover.js';
 export { sourceEvidenceAdmission } from './evidence-admission.js';
 export { collectDependencyIssues, resolveProjectImport } from './imports.js';
-export { importedSymbol, isLocallyDeclared, resolveImportedSymbol, location, objectProperty, propertyChain, staticText, unwrap, visit, } from './syntax.js';
+export { bindingContains, importedSymbol, isLocallyDeclared, resolveImportedSymbol, location, objectProperty, propertyChain, staticText, unwrap, visit, visitOwnBody, } from './syntax.js';
 export { assertSingleTypeUniverse } from './type-universe.js';
 export { observeQueryDefinitions } from './query-observation.js';
 export { queryCollectionKind } from './query-collection-type.js';

package/dist/tooling/linter/adapters/typescript/syntax.d.ts

@@ -27,12 +27,12 @@ export type ImportedSymbolResolution = Readonly<{
  */
 export declare function resolveImportedSymbol(file: SourceFile, expression: ts.Expression): ImportedSymbolResolution;
 export declare function isLocallyDeclared(identifier: ts.Identifier): boolean;
+export declare function bindingContains(binding: ts.BindingName, name: string): boolean;
+/** Visit a function body, without descending into the functions nested in it. */
+export declare function visitOwnBody(fn: ts.FunctionLikeDeclaration, callback: (node: ts.Node) => void): void;
 export declare function unwrap(expression: ts.Expression): ts.Expression;
 export declare function staticText(expression: ts.Expression | undefined): string | undefined;
 export declare function objectProperty(object: ts.ObjectLiteralExpression | undefined, name: string): ts.ObjectLiteralElementLike | undefined;
 export declare function propertyName(name: ts.PropertyName): string | undefined;
-export declare function callbackOf(property: ts.ObjectLiteralElementLike | undefined): ts.FunctionLikeDeclaration | undefined;
-export declare function objectArgument(call: ts.CallExpression): ts.ObjectLiteralExpression | undefined;
-export declare function isImportedCall(file: SourceFile, node: ts.Node, modules: ReadonlySet<string>, name: string): node is ts.CallExpression;
 export declare function propertyChain(expression: ts.Expression): readonly string[] | undefined;
 export declare function containingFunction(node: ts.Node): ts.FunctionLikeDeclaration | undefined;

package/dist/tooling/linter/adapters/typescript/syntax.js

@@ -103,11 +103,23 @@ function statementDeclares(statement, name) {
     }
     return false;
 }
-function bindingContains(binding, name) {
+export function bindingContains(binding, name) {
     if (ts.isIdentifier(binding))
         return binding.text === name;
     return binding.elements.some((element) => !ts.isOmittedExpression(element) && bindingContains(element.name, name));
 }
+/** Visit a function body, without descending into the functions nested in it. */
+export function visitOwnBody(fn, callback) {
+    if (!fn.body)
+        return;
+    const walk = (node) => {
+        callback(node);
+        if (node !== fn.body && ts.isFunctionLike(node))
+            return;
+        node.forEachChild(walk);
+    };
+    walk(fn.body);
+}
 export function unwrap(expression) {
     let current = expression;
     while (ts.isParenthesizedExpression(current) ||
@@ -138,30 +150,6 @@ export function propertyName(name) {
         return name.text;
     return ts.isComputedPropertyName(name) ? staticText(name.expression) : undefined;
 }
-export function callbackOf(property) {
-    if (!property)
-        return undefined;
-    if (ts.isMethodDeclaration(property))
-        return property;
-    if (ts.isPropertyAssignment(property)) {
-        const value = unwrap(property.initializer);
-        if (ts.isArrowFunction(value) || ts.isFunctionExpression(value))
-            return value;
-    }
-    return undefined;
-}
-export function objectArgument(call) {
-    const value = call.arguments[0];
-    return value && ts.isObjectLiteralExpression(unwrap(value))
-        ? unwrap(value)
-        : undefined;
-}
-export function isImportedCall(file, node, modules, name) {
-    if (!ts.isCallExpression(node))
-        return false;
-    const symbol = importedSymbol(file, node.expression);
-    return symbol?.name === name && modules.has(symbol.module);
-}
 export function propertyChain(expression) {
     const target = unwrap(expression);
     if (ts.isIdentifier(target))

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>;
@@ -25,4 +25,3 @@ export declare function callableReference(expression: ts.Expression): {
 };
 /** Resolve only one immutable lexical alias; the linter does not emulate program execution. */
 export declare function lexicalConstInitializer(identifier: ts.Identifier): ts.Expression | undefined;
-export declare function bindingContains(binding: ts.BindingName, name: string): boolean;

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 { bindingContains, 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];
@@ -227,8 +227,3 @@ export function lexicalConstInitializer(identifier) {
     }
     return undefined;
 }
-export function bindingContains(binding, name) {
-    if (ts.isIdentifier(binding))
-        return binding.text === name;
-    return binding.elements.some((element) => !ts.isOmittedExpression(element) && bindingContains(element.name, name));
-}