@astrale-os/cli 1.0.0-beta.2 → 1.0.0-beta.20

package/dist/types/admin/contract.d.ts

@@ -0,0 +1,26 @@
+import type { Input } from '@astrale-os/sdk/client';
+import type { ClientSession } from '@astrale-os/sdk/client/session';
+import type { ClassRef } from '@astrale-os/sdk/schema';
+import { Path } from '@astrale-os/sdk/graph/path';
+export declare const AdminContract: Readonly<{
+    origin: "admin.astrale.ai";
+    fleet: Path;
+    classes: Readonly<{
+        Domain: ClassRef;
+    }>;
+    edges: Readonly<{
+        fleetInstallsDomainByDefault: ClassRef;
+    }>;
+    properties: Readonly<{
+        domain: Readonly<{
+            origin: `${string}:class.${string}.property.origin`;
+            name: "kernel.astrale.ai:class.Named.property.name";
+            discoveryUrl: `${string}:class.${string}.property.discoveryUrl`;
+            description: "kernel.astrale.ai:class.Descriptable.property.description";
+            createdAt: "kernel.astrale.ai:class.Timestamped.property.createdAt";
+            updatedAt: "kernel.astrale.ai:class.Timestamped.property.updatedAt";
+        }>;
+    }>;
+}>;
+/** Invoke one stable Admin instance Method without schema discovery or reflection. */
+export declare function callAdminMethod(session: ClientSession, receiver: Path, method: string, input: Input): Promise<unknown>;

package/dist/types/admin/instance/client.d.ts

@@ -0,0 +1,20 @@
+import type { ClientSession } from '@astrale-os/sdk/client/session';
+import { type DomainInstallReceipt, type InstanceInfo, type OwnedInstanceInfo } from './model';
+export interface AdminInstanceContext {
+    readonly session: ClientSession;
+}
+export interface AdminInstanceApi {
+    list(): Promise<OwnedInstanceInfo[]>;
+    create(slug: string): Promise<InstanceInfo>;
+    status(identifier: string): Promise<InstanceInfo>;
+    delete(identifier: string): Promise<InstanceInfo>;
+    installDomain(identifier: string, domain: string): Promise<DomainInstallReceipt>;
+}
+export interface AdminInstanceDependencies {
+    readonly operationId?: (kind: 'create' | 'status' | 'delete' | 'install-domain') => string;
+}
+/**
+ * Connect the public Instance journey through stable Admin call paths. Routine
+ * operations perform no schema discovery. No Host lifecycle method is present.
+ */
+export declare function connectAdminInstances(context: AdminInstanceContext, dependencies?: AdminInstanceDependencies): Promise<AdminInstanceApi>;

package/dist/types/admin/instance/index.d.ts

@@ -0,0 +1,2 @@
+export { connectAdminInstances, type AdminInstanceApi, type AdminInstanceContext, type AdminInstanceDependencies, } from './client';
+export { AdminInstanceNotFoundError, findOwnedInstance, formatInstanceState, type DomainInstallReceipt, type InstanceInfo, type InstanceState, type OwnedInstanceInfo, } from './model';

package/dist/types/admin/instance/model.d.ts

@@ -6,10 +6,11 @@ export interface InstanceInfo {
     readonly url: string;
     readonly hostId?: string;
     readonly region?: string;
-    readonly state?: InstanceState;
+    readonly state: InstanceState;
     readonly phase?: string;
     readonly error?: string | null;
     readonly createdAt?: string;
+    readonly updatedAt?: string;
     readonly organizationId?: string;
 }
 /** An Instance returned through the caller-scoped Admin graph inventory. */
@@ -24,17 +25,12 @@ export interface DomainInstallReceipt {
     readonly installedRevision?: string;
     readonly error?: string;
 }
-export declare class AdminInstanceNotFoundError extends Error {
-    readonly identifier: string;
-    readonly name = "NotFoundError";
-    constructor(identifier: string);
-}
-export declare class AdminHostNotFoundError extends Error {
+export declare class AdminInstanceNotFoundError extends AstraleError {
     readonly identifier: string;
-    readonly name = "NotFoundError";
     constructor(identifier: string);
 }
 /** Match an owner-scoped Instance by slug, canonical Node Path, or bare Node id. */
 export declare function findOwnedInstance(instances: readonly OwnedInstanceInfo[], identifier: string): OwnedInstanceInfo | undefined;
-/** Human-readable location of an Instance (state, region, and Host Path). */
-export declare function formatInstanceLocation(info: InstanceInfo): string;
+/** Human-readable non-ready lifecycle state for one Instance. */
+export declare function formatInstanceState(info: InstanceInfo): string;
+import { AstraleError } from '../../errors';

package/dist/types/connection/auth.d.ts

@@ -1,4 +1,5 @@
 import type { AstraleConfig } from '../lib/config';
+import type { ConnectionOptions, ConnectionTarget } from './target';
 import { type Identity } from '../identity/registry';
 import { IdpAudienceMismatchError } from '../lib/idp';
 import { IdpSessionNoRefreshTokenError } from '../lib/idp-session';
@@ -7,6 +8,8 @@ export type KeyIdentityAuthOptions = {
     subject?: string;
     audience: string;
 };
+/** Pin the local identity label before a session performs any authenticated effect. */
+export declare function bindCredentialIdentity<Options extends ConnectionOptions>(options: Options, target: ConnectionTarget): Promise<Options>;
 /**
  * Resolve a signed JWT credential from CLI options.
  *

package/dist/types/connection/call.d.ts

@@ -0,0 +1,3 @@
+import { type Call } from '@astrale-os/sdk/client';
+/** Convert the CLI's untrusted text/JSON boundary into the one public Call representation. */
+export declare function createPathCall(path: string, input: unknown): Call;

package/dist/types/connection/command.d.ts

@@ -0,0 +1,27 @@
+import type { ConnectionContext } from './session';
+import type { ConnectionOptions } from './target';
+export interface KernelCommandOpts extends ConnectionOptions {
+    readonly raw?: boolean;
+    readonly json?: boolean;
+    readonly format?: 'yaml' | 'json';
+    readonly debug?: boolean;
+}
+export interface OperationRecovery {
+    readonly operation: string;
+    readonly retry: string;
+}
+/**
+ * Encapsulates the standard kernel command lifecycle:
+ * spinner → connect → call → timing → output → error handling.
+ *
+ * Commands provide a `fn` that does the actual work and an optional
+ * `format` callback for custom output. If `format` is omitted, the
+ * result is passed to the standard `output()` function.
+ */
+export declare function runKernelCommand<T>(input: {
+    readonly opts: KernelCommandOpts;
+    readonly label: string;
+    readonly recovery?: OperationRecovery;
+    readonly fn: (context: ConnectionContext) => Promise<T>;
+    readonly format?: (result: T, options: KernelCommandOpts, machine: boolean) => void | Promise<void>;
+}): Promise<void>;

package/dist/types/connection/credential.d.ts

@@ -0,0 +1,14 @@
+import type { Fetch } from '@astrale-os/sdk/client';
+import type { SessionAuth } from '@astrale-os/sdk/client/session';
+import { type IssuerId } from '@astrale-os/sdk/auth';
+import type { AstraleConfig } from '../lib/config';
+import type { ConnectionOptions, ConnectionTarget } from './target';
+export interface SourceCredentialResolver {
+    resolve(audience: IssuerId, signal: AbortSignal): Promise<string>;
+}
+/** Resolve source authority; an omitted Session delegation preserves exact current authority. */
+export declare function createConnectionCredential(expectedSourceIssuer: IssuerId, source: SourceCredentialResolver): SessionAuth;
+/** Bind CLI identity state and Core Auth delegation to one Session auth capability. */
+export declare function createCliCredential(target: ConnectionTarget, options: ConnectionOptions, config: AstraleConfig, fetch?: Fetch, timeoutMs?: number): SessionAuth | undefined;
+/** Reject contradictory explicit credential selections before identity or network access. */
+export declare function validateCredentialSelection(options: ConnectionOptions): void;

package/dist/types/connection/errors.d.ts

@@ -0,0 +1 @@
+export { formatKernelError, functionInputIssues, schemaUpgradeHint } from './failure';

package/dist/types/connection/exchange.d.ts

@@ -0,0 +1,9 @@
+import type { IssuerId } from '@astrale-os/sdk/auth';
+import type { Fetch } from '@astrale-os/sdk/client';
+import type { SourceCredentialResolver } from './credential';
+import type { ConnectionTarget } from './target';
+import { ExchangeCredentialCache } from '../state/exchange-credentials';
+/** Exchange exact authenticated User authority for a Domain bearer bound to this Kernel. */
+export declare function createExchangeCredentialResolver(target: ConnectionTarget & {
+    readonly domainIssuer: IssuerId;
+}, source: SourceCredentialResolver, fetch: Fetch, timeoutMs: number, cache?: ExchangeCredentialCache): SourceCredentialResolver;

package/dist/types/connection/failure/classify.d.ts

@@ -0,0 +1,2 @@
+import type { FailureDiagnostic } from './model';
+export declare function classifyFailure(error: unknown): FailureDiagnostic;

package/dist/types/connection/failure/index.d.ts

@@ -0,0 +1,5 @@
+import type { OperationRecovery } from '../command';
+export { functionInputIssues, schemaUpgradeHint } from '../reasons';
+export declare function formatKernelError(error: unknown, machine: boolean, urlArg?: string, debug?: boolean, options?: {
+    recovery?: OperationRecovery;
+}): Promise<void>;

package/dist/types/connection/failure/model.d.ts

@@ -0,0 +1,25 @@
+export type TransportDiagnosticContext = {
+    readonly kind: 'acquisition';
+    readonly resource: 'publication' | 'bundle';
+} | {
+    readonly kind: 'invocation';
+    readonly delivery: 'not-sent' | 'unknown';
+    readonly invocation?: unknown;
+};
+export type FailureDiagnostic = {
+    readonly kind: 'simple';
+    readonly code: string;
+    readonly message: string;
+    readonly hint?: string;
+} | {
+    readonly kind: 'response';
+    readonly code: number;
+    readonly message: string;
+    readonly reason?: unknown;
+} | {
+    readonly kind: 'transport';
+    readonly code: 'CONNECTION_ERROR' | 'DISCONNECTED' | 'TIMEOUT' | 'TRANSPORT_ERROR';
+    readonly message: string;
+    readonly phase: string;
+    readonly context: TransportDiagnosticContext;
+};

package/dist/types/connection/failure/render.d.ts

@@ -0,0 +1,3 @@
+import type { OperationRecovery } from '../command';
+import type { FailureDiagnostic } from './model';
+export declare function renderFailure(failure: FailureDiagnostic, machine: boolean, url: string, recovery: OperationRecovery | undefined): void;

package/dist/types/connection/index.d.ts

@@ -0,0 +1,8 @@
+export { createPathCall } from './call';
+export { runKernelCommand } from './command';
+export type { KernelCommandOpts, OperationRecovery } from './command';
+export { expandSelfInCall, expandSelfInPath, withSelfHint } from './self';
+export type { SelfExpansionMeta } from './self';
+export { withAdminClientSession, withClientSession, type ConnectionContext } from './session';
+export { registrationKeyForTarget } from './target';
+export type { AdminConnectionOptions, ConnectionOptions, ConnectionTarget } from './target';

package/dist/types/connection/reasons.d.ts

@@ -0,0 +1,37 @@
+export type FunctionInputIssue = Readonly<{
+    code: string;
+    path?: string;
+    message: string;
+}>;
+export type QueryInputRepair = Readonly<{
+    phase: 'decode' | 'input';
+    path: string;
+}> | Readonly<{
+    phase: 'plan';
+    issue: string;
+    path?: string;
+}> | Readonly<{
+    phase: 'limit';
+    limit: string;
+    maximum: number;
+    actual: number;
+    path?: string;
+}>;
+export type SchemaUpgradeDetails = {
+    readonly origin?: string;
+    readonly issue?: undefined;
+} | {
+    readonly origin: string;
+    readonly issue: 'issuer-changed';
+    readonly installedIssuer: string;
+    readonly replacementIssuer: string;
+};
+export declare function reasonCode(reason: unknown): string | undefined;
+/** Admit only bounded caller-safe Function input issues established by the Kernel. */
+export declare function functionInputIssues(reason: unknown): readonly FunctionInputIssue[];
+/** Admit only public Query-input repair variants; unknown details remain machine-only. */
+export declare function queryInputRepair(reason: unknown): QueryInputRepair | undefined;
+/** Decode bounded recovery guidance while preserving the admitted reason itself elsewhere. */
+export declare function schemaUpgradeDetails(reason: unknown): SchemaUpgradeDetails | undefined;
+export declare function schemaUpgradeHint(details: SchemaUpgradeDetails): string;
+export declare function schemaDataRemovalHint(reason: unknown): string | undefined;

package/dist/types/connection/self.d.ts

@@ -0,0 +1,37 @@
+import type { ConnectionContext } from './session';
+/** Metadata attached to errors after an authenticated caller-authored @self expansion. */
+export interface SelfExpansionMeta {
+    readonly original: string;
+    readonly expanded: string;
+    readonly selfId: string;
+    readonly slug?: string;
+}
+/**
+ * Run `action`; if it throws NodeUnavailableError, retain the authenticated
+ * expansion for precise diagnostics. The error is re-thrown either way.
+ */
+export declare function withSelfHint<T>(action: () => Promise<T>, meta: SelfExpansionMeta | undefined): Promise<T>;
+type AuthenticatedSelf = {
+    readonly id?: unknown;
+    readonly slug?: string;
+};
+export type ResolveSelfIdDependencies = {
+    readonly whoami?: (context: ConnectionContext) => Promise<AuthenticatedSelf>;
+};
+/** Resolve @self only from the effective principal authenticated by the selected Kernel. */
+export declare function resolveSelfIdAuthenticated(context: ConnectionContext, dependencies?: ResolveSelfIdDependencies): Promise<{
+    readonly id: string;
+    readonly slug?: string;
+}>;
+/** Expand @self in path-like commands and return metadata for NotFound diagnostics. */
+export declare function expandSelfInPath(path: string, context: ConnectionContext): Promise<{
+    readonly path: string;
+    readonly meta?: SelfExpansionMeta;
+}>;
+/** Expand @self once across one Call path and its CLI-authored string parameters. */
+export declare function expandSelfInCall(path: string, parameters: Readonly<Record<string, unknown>>, context: ConnectionContext): Promise<{
+    readonly path: string;
+    readonly parameters: Readonly<Record<string, unknown>>;
+    readonly meta?: SelfExpansionMeta;
+}>;
+export {};

package/dist/types/connection/session.d.ts

@@ -0,0 +1,31 @@
+import type { AuthApi } from '@astrale-os/sdk/auth';
+import type { GraphApi } from '@astrale-os/sdk/client';
+import type { ClientSessionOptions, SessionAuth } from '@astrale-os/sdk/client/session';
+import { ClientSession } from '@astrale-os/sdk/client/session';
+import type { AstraleConfig } from '../lib/config';
+import type { AdminConnectionOptions, ConnectionOptions, ConnectionTarget } from './target';
+import { connectAdminInstances, type InstanceInfo } from '../admin/instance';
+export interface ConnectionContext {
+    readonly session: ClientSession;
+    readonly graph: GraphApi;
+    readonly auth: AuthApi;
+    readonly target: ConnectionTarget;
+    /** Local identity label selected for this session; absent for raw credentials or anonymous use. */
+    readonly identity?: string;
+}
+interface OwnedConnection {
+    readonly context: ConnectionContext;
+    close(): void;
+}
+export type ConnectionFactory = (target: ConnectionTarget, timeoutMs: number, options: ConnectionOptions, config: AstraleConfig) => OwnedConnection;
+/** Resolve one ordinary target, run a command action, then close terminally. */
+export declare function withClientSession<Value>(options: ConnectionOptions, action: (context: ConnectionContext) => Promise<Value>): Promise<Value>;
+/** Resolve the configured Admin Domain target under the same terminal lifecycle. */
+export declare function withAdminClientSession<Value>(options: AdminConnectionOptions, action: (context: ConnectionContext) => Promise<Value>): Promise<Value>;
+/** Owner-private seam used to prove validation order and cleanup without network I/O. */
+export declare function withResolvedClientSession<Value>(target: ConnectionTarget, options: ConnectionOptions, config: AstraleConfig, action: (context: ConnectionContext) => Promise<Value>, open?: ConnectionFactory): Promise<Value>;
+export declare function resolveTimeoutMs(raw: string | undefined): number;
+/** Owner-private construction seam proving that transport and source identity stay distinct. */
+export declare function createClientSessionOptions(target: ConnectionTarget, fetch: NonNullable<ClientSessionOptions['fetch']>, auth: SessionAuth | undefined, timeoutMs: number): ClientSessionOptions;
+export declare function lookupManagedInstance(slug: string, options: ConnectionOptions, openAdmin?: typeof withAdminClientSession, connect?: typeof connectAdminInstances): Promise<InstanceInfo>;
+export {};

package/dist/types/connection/target.d.ts

@@ -0,0 +1,38 @@
+import type { IssuerId } from '@astrale-os/sdk/auth';
+import type { InstanceInfo } from '../lib/admin-instance';
+import type { AdminTargetCommandOpts } from '../lib/admin-target';
+import type { AstraleConfig } from '../lib/config';
+import type { InstanceStore } from '../lib/instance';
+export interface ConnectionOptions {
+    readonly url?: string;
+    readonly instance?: string;
+    readonly timeout?: string;
+    readonly as?: string;
+    readonly creds?: string;
+    readonly anonymous?: boolean;
+    readonly ci?: boolean;
+}
+export interface AdminConnectionOptions extends ConnectionOptions {
+    readonly admin?: string;
+    readonly adminUrl?: string;
+    readonly domainIssuer?: string;
+}
+export interface ConnectionTarget {
+    readonly url: string;
+    readonly kernelIssuer: IssuerId;
+    readonly domainIssuer?: IssuerId;
+    readonly slug?: string;
+    readonly defaultIdentity?: string;
+    readonly caFile?: string;
+}
+export interface TargetDependencies {
+    readonly instances?: InstanceStore;
+    readonly managed?: (slug: string) => Promise<InstanceInfo>;
+}
+/** Stable local identity-registration key for the exact selected source Kernel. */
+export declare function registrationKeyForTarget(target: ConnectionTarget): string;
+/** Resolve the existing URL / instance / active precedence into one exact source Kernel. */
+export declare function resolveConnectionTarget(options: ConnectionOptions, config: AstraleConfig, dependencies?: TargetDependencies): Promise<ConnectionTarget>;
+/** Resolve the configured Admin Domain target without entering managed-instance discovery. */
+export declare function resolveAdminConnectionTarget(options: AdminConnectionOptions, config: AstraleConfig, instances?: InstanceStore): Promise<ConnectionTarget>;
+export declare function adminLookupOptions(options: AdminConnectionOptions): AdminTargetCommandOpts;

package/dist/types/errors.d.ts

@@ -1,7 +1,7 @@
 export declare class AstraleError extends Error {
     code: string;
     hint?: string;
-    constructor(code: string, message: string, hint?: string);
+    constructor(code: string, message: string, hint?: string, options?: ErrorOptions);
 }
 export declare class AuthError extends AstraleError {
     constructor(message: string, hint?: string);

package/dist/types/lib/admin-instance.d.ts

@@ -0,0 +1,17 @@
+import type { AdminConnectionOptions, ConnectionContext } from '../connection';
+export { AdminInstanceNotFoundError, findOwnedInstance, formatInstanceState, type InstanceInfo, type InstanceState, type OwnedInstanceInfo, } from '../admin/instance';
+/** Resolve the Admin target and read only the caller-visible Instance inventory. */
+export declare function listOwnedInstances(options: AdminConnectionOptions): Promise<import("./admin-instance").OwnedInstanceInfo[]>;
+/** Read caller-visible inventory together with the exact local identity used for the Admin call. */
+export declare function listOwnedInstancesWithIdentity(options: AdminConnectionOptions): Promise<Readonly<{
+    instances: import("./admin-instance").OwnedInstanceInfo[];
+    identity?: string | undefined;
+}>>;
+/** Reuse an already-open Admin session for a caller-visible Instance inventory. */
+export declare function listOwnedInstancesInContext(context: ConnectionContext): Promise<import("./admin-instance").OwnedInstanceInfo[]>;
+/** Request one managed Instance; Admin owns infrastructure placement. */
+export declare function createOwnedInstance(options: AdminConnectionOptions, slug: string): Promise<import("./admin-instance").InstanceInfo>;
+/** Refresh one exact caller-visible Instance through its V2 receiver Method. */
+export declare function statusOwnedInstance(options: AdminConnectionOptions, identifier: string): Promise<import("./admin-instance").InstanceInfo>;
+/** Delete one exact caller-visible Instance through its V2 receiver Method. */
+export declare function deleteOwnedInstance(options: AdminConnectionOptions, identifier: string): Promise<import("./admin-instance").InstanceInfo>;

package/dist/types/lib/admin-target.d.ts

@@ -2,50 +2,25 @@ import { z } from 'zod';
 import type { AstraleConfig } from './config';
 import type { InstanceStore } from './instance';
 export declare const DEFAULT_ADMIN_TARGET_NAME = "admin";
-export declare const DEFAULT_ADMIN_TARGET_URL = "https://admin.eu.astrale.ai/api";
-export declare const DEFAULT_ADMIN_DOMAIN_ISSUER = "https://admin.beta.astrale.ai";
+export declare function defaultAdminTargetForChannel(channel: string): {
+    readonly url: string;
+    readonly domainIssuer: string;
+};
+export declare const DEFAULT_ADMIN_TARGET_URL: string;
+export declare const DEFAULT_ADMIN_DOMAIN_ISSUER: string;
 export declare const DEFAULT_ADMIN_TARGET_CONFIG: {
     name: string;
     url: string;
     kernelIssuer: string;
     domainIssuer: string;
 };
-export declare const AdminTargetConfigSchema: z.ZodEffects<z.ZodObject<{
-    /** Friendly name / auth registration slug for direct URL admin targets. */
+export declare const AdminTargetConfigSchema: z.ZodObject<{
     name: z.ZodOptional<z.ZodString>;
-    /** Direct admin kernel URL. */
-    url: z.ZodOptional<z.ZodEffects<z.ZodString, string, string>>;
-    /** Kernel issuer / JWT audience when different from url. */
-    kernelIssuer: z.ZodOptional<z.ZodEffects<z.ZodString, string, string>>;
-    /** Exact native Admin Domain issuer used by the standard token exchange. */
-    domainIssuer: z.ZodOptional<z.ZodEffects<z.ZodString, string, string>>;
-    /** Bookmark name for the admin kernel. */
+    url: z.ZodOptional<z.ZodString>;
+    kernelIssuer: z.ZodOptional<z.ZodString>;
+    domainIssuer: z.ZodOptional<z.ZodString>;
     instance: z.ZodOptional<z.ZodString>;
-}, "strip", z.ZodTypeAny, {
-    name?: string | undefined;
-    url?: string | undefined;
-    kernelIssuer?: string | undefined;
-    domainIssuer?: string | undefined;
-    instance?: string | undefined;
-}, {
-    name?: string | undefined;
-    url?: string | undefined;
-    kernelIssuer?: string | undefined;
-    domainIssuer?: string | undefined;
-    instance?: string | undefined;
-}>, {
-    name?: string | undefined;
-    url?: string | undefined;
-    kernelIssuer?: string | undefined;
-    domainIssuer?: string | undefined;
-    instance?: string | undefined;
-}, {
-    name?: string | undefined;
-    url?: string | undefined;
-    kernelIssuer?: string | undefined;
-    domainIssuer?: string | undefined;
-    instance?: string | undefined;
-}>;
+}, z.core.$strip>;
 export type AdminTargetConfig = z.infer<typeof AdminTargetConfigSchema>;
 export type AdminTargetCommandOpts = {
     admin?: string;

package/dist/types/lib/config.d.ts

@@ -1,69 +1,17 @@
 import { z } from 'zod';
 export declare const AstraleConfigSchema: z.ZodObject<{
     issuer: z.ZodDefault<z.ZodString>;
-    admin: z.ZodDefault<z.ZodEffects<z.ZodObject<{
+    admin: z.ZodDefault<z.ZodObject<{
         name: z.ZodOptional<z.ZodString>;
-        url: z.ZodOptional<z.ZodEffects<z.ZodString, string, string>>;
-        kernelIssuer: z.ZodOptional<z.ZodEffects<z.ZodString, string, string>>;
-        domainIssuer: z.ZodOptional<z.ZodEffects<z.ZodString, string, string>>;
+        url: z.ZodOptional<z.ZodString>;
+        kernelIssuer: z.ZodOptional<z.ZodString>;
+        domainIssuer: z.ZodOptional<z.ZodString>;
         instance: z.ZodOptional<z.ZodString>;
-    }, "strip", z.ZodTypeAny, {
-        name?: string | undefined;
-        url?: string | undefined;
-        kernelIssuer?: string | undefined;
-        domainIssuer?: string | undefined;
-        instance?: string | undefined;
-    }, {
-        name?: string | undefined;
-        url?: string | undefined;
-        kernelIssuer?: string | undefined;
-        domainIssuer?: string | undefined;
-        instance?: string | undefined;
-    }>, {
-        name?: string | undefined;
-        url?: string | undefined;
-        kernelIssuer?: string | undefined;
-        domainIssuer?: string | undefined;
-        instance?: string | undefined;
-    }, {
-        name?: string | undefined;
-        url?: string | undefined;
-        kernelIssuer?: string | undefined;
-        domainIssuer?: string | undefined;
-        instance?: string | undefined;
-    }>>;
+    }, z.core.$strip>>;
     telemetry: z.ZodDefault<z.ZodObject<{
         enabled: z.ZodDefault<z.ZodBoolean>;
-    }, "strip", z.ZodTypeAny, {
-        enabled: boolean;
-    }, {
-        enabled?: boolean | undefined;
-    }>>;
-}, "strip", z.ZodTypeAny, {
-    issuer: string;
-    admin: {
-        name?: string | undefined;
-        url?: string | undefined;
-        kernelIssuer?: string | undefined;
-        domainIssuer?: string | undefined;
-        instance?: string | undefined;
-    };
-    telemetry: {
-        enabled: boolean;
-    };
-}, {
-    issuer?: string | undefined;
-    admin?: {
-        name?: string | undefined;
-        url?: string | undefined;
-        kernelIssuer?: string | undefined;
-        domainIssuer?: string | undefined;
-        instance?: string | undefined;
-    } | undefined;
-    telemetry?: {
-        enabled?: boolean | undefined;
-    } | undefined;
-}>;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
 export type AstraleConfig = z.infer<typeof AstraleConfigSchema>;
 export declare const DEFAULT_CONFIG: AstraleConfig;
 export declare function readConfig(): Promise<AstraleConfig>;

package/dist/types/lib/failure-debug.d.ts

@@ -0,0 +1 @@
+export declare function printFailureDebug(error: unknown, url: string): void;