@astrale-os/kernel-core 0.9.0-beta.9 → 0.9.0

package/dist/auth/expression/normalization/raise-denials.d.ts

@@ -1,3 +0,0 @@
-import type { IdentityExpr } from '../language/index.js';
-/** Raise every positive-position exclusion into one Grant-wide veto. */
-export declare function raiseDenials(expr: IdentityExpr): IdentityExpr;

package/dist/auth/expression/normalization/raise-denials.js

@@ -1,59 +0,0 @@
-/** Raise every positive-position exclusion into one Grant-wide veto. */
-export function raiseDenials(expr) {
-    const denials = [...collectDenials(expr, new WeakMap())];
-    if (denials.length === 0)
-        return expr;
-    return Object.freeze({
-        kind: 'exclude',
-        base: stripExcludes(expr, new WeakMap()),
-        excluded: Object.freeze(denials),
-    });
-}
-function stripExcludes(expr, memo) {
-    const cached = memo.get(expr);
-    if (cached !== undefined)
-        return cached;
-    let stripped;
-    switch (expr.kind) {
-        case 'identity':
-            stripped = expr;
-            break;
-        case 'union':
-        case 'intersect':
-            stripped = Object.freeze({
-                kind: expr.kind,
-                operands: Object.freeze(expr.operands.map((operand) => stripExcludes(operand, memo))),
-            });
-            break;
-        case 'exclude':
-            stripped = stripExcludes(expr.base, memo);
-            break;
-    }
-    memo.set(expr, stripped);
-    return stripped;
-}
-function collectDenials(expr, memo) {
-    const cached = memo.get(expr);
-    if (cached !== undefined)
-        return cached;
-    const denials = new Set();
-    switch (expr.kind) {
-        case 'identity':
-            break;
-        case 'union':
-        case 'intersect':
-            for (const operand of expr.operands) {
-                for (const denial of collectDenials(operand, memo))
-                    denials.add(denial);
-            }
-            break;
-        case 'exclude':
-            for (const excluded of expr.excluded)
-                denials.add(excluded);
-            for (const denial of collectDenials(expr.base, memo))
-                denials.add(denial);
-            break;
-    }
-    memo.set(expr, denials);
-    return denials;
-}

package/dist/auth/provision/fingerprint/fingerprint.d.ts

@@ -1,9 +0,0 @@
-import type { ProvisionRequest } from '../index.js';
-declare const PROVISION_FINGERPRINT: unique symbol;
-/** Digest of the semantic request. Self-proof bytes are deliberately excluded. */
-export type ProvisionFingerprint = `sha256:${string}` & {
-    readonly [PROVISION_FINGERPRINT]: true;
-};
-/** Compute a deterministic semantic request digest without retaining bearer proof bytes. */
-export declare function fingerprint(request: ProvisionRequest): Promise<ProvisionFingerprint>;
-export {};

package/dist/auth/provision/fingerprint/fingerprint.js

@@ -1,33 +0,0 @@
-import * as portable from '@astrale-os/kernel-dsl/value';
-import { MutationAST } from '../../../graph/mutate/index.js';
-/** Compute a deterministic semantic request digest without retaining bearer proof bytes. */
-export async function fingerprint(request) {
-    const identities = Object.fromEntries(Object.entries(request.identities)
-        .sort(([left], [right]) => compare(left, right))
-        .map(([binding, input]) => [
-        binding,
-        input.credentials !== undefined
-            ? {
-                credentials: { publicKey: input.credentials.publicKey },
-                requiredClaims: input.requiredClaims ?? [],
-            }
-            : {
-                issuer: input.issuer,
-                subject: input.subject,
-                requiredClaims: input.requiredClaims ?? [],
-            },
-    ]));
-    const basis = portable.json.encode(portable.accept({
-        idempotencyKey: request.idempotencyKey,
-        mutation: MutationAST.encode(request.mutation),
-        identities,
-    }));
-    const digest = await crypto.subtle.digest('SHA-256', Uint8Array.from(basis).buffer);
-    return `sha256:${hex(new Uint8Array(digest))}`;
-}
-function compare(left, right) {
-    return left < right ? -1 : left > right ? 1 : 0;
-}
-function hex(input) {
-    return [...input].map((value) => value.toString(16).padStart(2, '0')).join('');
-}

package/dist/auth/provision/fingerprint/index.d.ts

@@ -1,2 +0,0 @@
-export { fingerprint } from './fingerprint.js';
-export type { ProvisionFingerprint } from './fingerprint.js';

package/dist/auth/provision/index.d.ts

@@ -1,5 +0,0 @@
-export { fingerprint } from './fingerprint/index.js';
-export type { ProvisionFingerprint } from './fingerprint/index.js';
-export { accept, isSelfIssuer, selfIssuer } from './request/index.js';
-export type { AssertedIdentityProvision, IdentityProvisionInput, ProvisionRequest, RequiredClaims, SelfIdentityProvision, } from './request/index.js';
-export type { ProvisionedIdentity, ProvisionResult } from './result/index.js';

package/dist/auth/provision/request/admission.d.ts

@@ -1,3 +0,0 @@
-import type { ProvisionRequest } from './request.js';
-/** Admit unknown input into the exact immutable Provision request language. */
-export declare function accept(input: unknown): ProvisionRequest;

package/dist/auth/provision/request/admission.js

@@ -1,125 +0,0 @@
-import * as portable from '@astrale-os/kernel-dsl/value';
-import { isLocalBinding } from '../../../graph/graph/index.js';
-import { MutationAST } from '../../../graph/mutate/index.js';
-import { admitConstraint, MAX_REQUIRED_CLAIMS } from '../../claims/admission/index.js';
-import { AuthValueError } from '../../error.js';
-import { accept as acceptIssuer } from '../../issuer/index.js';
-import { acceptPublic } from '../../jwk/index.js';
-const PROOF_BYTES_LIMIT = 64 * 1024;
-const textEncoder = new TextEncoder();
-/** Admit unknown input into the exact immutable Provision request language. */
-export function accept(input) {
-    if (!isRecord(input))
-        invalid('', 'Expected a Provision request object');
-    exact(input, ['idempotencyKey', 'identities', 'mutation'], '');
-    if (typeof input.idempotencyKey !== 'string' || input.idempotencyKey.length === 0) {
-        invalid('/idempotencyKey', 'Expected a non-empty idempotency key');
-    }
-    const mutation = MutationAST.decode(input.mutation);
-    if (!isRecord(input.identities))
-        invalid('/identities', 'Expected an Identity binding map');
-    const identities = {};
-    for (const binding of Object.keys(input.identities).sort(compare)) {
-        if (!isLocalBinding(binding))
-            invalid(`/identities/${pointer(binding)}`, 'Invalid LocalBinding');
-        identities[binding] = identityInput(input.identities[binding], `/identities/${pointer(binding)}`);
-    }
-    return Object.freeze({
-        idempotencyKey: input.idempotencyKey,
-        mutation,
-        identities: Object.freeze(identities),
-    });
-}
-function identityInput(input, path) {
-    if (!isRecord(input))
-        invalid(path, 'Expected an Identity provision object');
-    const requiredClaims = constraints(input.requiredClaims, `${path}/requiredClaims`);
-    if (Object.hasOwn(input, 'credentials')) {
-        exact(input, input.requiredClaims === undefined ? ['credentials'] : ['credentials', 'requiredClaims'], path);
-        if (!isRecord(input.credentials))
-            invalid(`${path}/credentials`, 'Expected credentials');
-        exact(input.credentials, ['proof', 'publicKey'], `${path}/credentials`);
-        return Object.freeze({
-            credentials: Object.freeze({
-                publicKey: publicJwk(input.credentials.publicKey, `${path}/credentials/publicKey`),
-                proof: credentialProof(input.credentials.proof, `${path}/credentials/proof`),
-            }),
-            ...(requiredClaims.length === 0 ? {} : { requiredClaims }),
-        });
-    }
-    exact(input, input.requiredClaims === undefined
-        ? ['issuer', 'subject']
-        : ['issuer', 'requiredClaims', 'subject'], path);
-    if (typeof input.issuer !== 'string')
-        invalid(`${path}/issuer`, 'Expected an issuer');
-    let issuer;
-    try {
-        issuer = acceptIssuer(input.issuer);
-    }
-    catch (cause) {
-        invalid(`${path}/issuer`, 'Expected a canonical issuer', cause);
-    }
-    if (typeof input.subject !== 'string' || input.subject.length === 0)
-        invalid(`${path}/subject`, 'Expected a non-empty subject');
-    return Object.freeze({
-        issuer,
-        subject: input.subject,
-        ...(requiredClaims.length === 0 ? {} : { requiredClaims }),
-    });
-}
-function credentialProof(input, path) {
-    if (typeof input === 'string') {
-        const bytes = textEncoder.encode(input).byteLength;
-        if (bytes === 0 || bytes > PROOF_BYTES_LIMIT)
-            invalid(path, `Credential proof must contain 1-${PROOF_BYTES_LIMIT} bytes`);
-        return input;
-    }
-    if (!(input instanceof Uint8Array) ||
-        input.byteLength === 0 ||
-        input.byteLength > PROOF_BYTES_LIMIT) {
-        invalid(path, `Credential proof must contain 1-${PROOF_BYTES_LIMIT} bytes`);
-    }
-    return input.slice();
-}
-function publicJwk(input, path) {
-    try {
-        return acceptPublic(input);
-    }
-    catch (cause) {
-        invalid(path, 'Expected a thumbprintable public JWK', cause);
-    }
-}
-function constraints(input, path) {
-    if (input === undefined)
-        return Object.freeze([]);
-    if (!Array.isArray(input) || input.length > MAX_REQUIRED_CLAIMS)
-        invalid(path, `Expected at most ${MAX_REQUIRED_CLAIMS} required-claim constraints`);
-    return Object.freeze(input.map((item, index) => {
-        let admitted;
-        try {
-            admitted = portable.accept(item);
-        }
-        catch (cause) {
-            invalid(`${path}/${index}`, 'Expected a portable claim constraint', cause);
-        }
-        return admitConstraint(admitted, `${path}/${index}`, invalid);
-    }));
-}
-function isRecord(input) {
-    return input !== null && typeof input === 'object' && !Array.isArray(input);
-}
-function exact(input, expected, path) {
-    const actual = Object.keys(input).sort(compare);
-    const wanted = [...expected].sort(compare);
-    if (actual.length !== wanted.length || actual.some((key, index) => key !== wanted[index]))
-        invalid(path, `Expected exactly ${expected.join(', ')}`);
-}
-function pointer(input) {
-    return input.replaceAll('~', '~0').replaceAll('/', '~1');
-}
-function compare(left, right) {
-    return left < right ? -1 : left > right ? 1 : 0;
-}
-function invalid(path, message, cause) {
-    throw new AuthValueError('AUTH_PROVISION_REQUEST_INVALID', message, path, cause === undefined ? undefined : { cause });
-}

package/dist/auth/provision/request/index.d.ts

@@ -1,3 +0,0 @@
-export { accept } from './admission.js';
-export { isSelfIssuer, selfIssuer } from './self-issuer.js';
-export type { AssertedIdentityProvision, IdentityProvisionInput, ProvisionRequest, RequiredClaims, SelfIdentityProvision, } from './request.js';

package/dist/auth/provision/request/request.d.ts

@@ -1,29 +0,0 @@
-import type { LocalBinding, MutationAST } from '../../../graph/mutate/index.js';
-import type { ClaimConstraint } from '../../claims/index.js';
-import type { CredentialInput } from '../../credential/input/index.js';
-import type { Subject } from '../../identity/index.js';
-import type { IssuerId } from '../../issuer/index.js';
-import type { JsonWebKey } from '../../jwk/index.js';
-export type RequiredClaims = readonly ClaimConstraint[];
-export interface AssertedIdentityProvision {
-    readonly issuer: IssuerId;
-    readonly subject: Subject;
-    readonly requiredClaims?: RequiredClaims;
-    readonly credentials?: never;
-}
-export interface SelfIdentityProvision {
-    readonly credentials: {
-        readonly publicKey: JsonWebKey;
-        readonly proof: CredentialInput;
-    };
-    readonly requiredClaims?: RequiredClaims;
-    readonly issuer?: never;
-    readonly subject?: never;
-}
-export type IdentityProvisionInput = AssertedIdentityProvision | SelfIdentityProvision;
-/** One conditional graph transition whose Identity births are explicitly designated by binding. */
-export interface ProvisionRequest {
-    readonly idempotencyKey: string;
-    readonly mutation: MutationAST;
-    readonly identities: Readonly<Record<LocalBinding, IdentityProvisionInput>>;
-}

package/dist/auth/provision/result/index.d.ts

@@ -1 +0,0 @@
-export type { ProvisionedIdentity, ProvisionResult } from './result.js';

package/dist/auth/provision/result/result.d.ts

@@ -1,12 +0,0 @@
-import type { LocalBinding } from '../../../graph/mutate/index.js';
-import type { NodeId } from '../../../graph/node/index.js';
-import type { Subject } from '../../identity/index.js';
-import type { IssuerId } from '../../issuer/index.js';
-export interface ProvisionedIdentity {
-    readonly issuer: IssuerId;
-    readonly subject: Subject;
-}
-export interface ProvisionResult {
-    readonly createdNodes: Readonly<Record<LocalBinding, NodeId>>;
-    readonly identities: Readonly<Record<LocalBinding, ProvisionedIdentity>>;
-}

package/dist/graph/graph/navigation/error.d.ts

@@ -1,12 +0,0 @@
-import type { NodePath } from '../../path/index.js';
-export declare class GraphPathAmbiguousError extends Error {
-    readonly path: NodePath;
-    readonly matches: number;
-    readonly code: 'GRAPH_PATH_AMBIGUOUS';
-    constructor(path: NodePath, matches: number);
-}
-export declare class GraphPathWalkerRequiredError extends Error {
-    readonly path: NodePath;
-    readonly code: 'GRAPH_PATH_WALKER_REQUIRED';
-    constructor(path: NodePath);
-}

package/dist/graph/graph/navigation/error.js

@@ -1,20 +0,0 @@
-export class GraphPathAmbiguousError extends Error {
-    path;
-    matches;
-    code = 'GRAPH_PATH_AMBIGUOUS';
-    constructor(path, matches) {
-        super(`Graph Path ${JSON.stringify(path)} matched ${matches} distinct Nodes.`);
-        this.path = path;
-        this.matches = matches;
-        this.name = 'GraphPathAmbiguousError';
-    }
-}
-export class GraphPathWalkerRequiredError extends Error {
-    path;
-    code = 'GRAPH_PATH_WALKER_REQUIRED';
-    constructor(path) {
-        super(`Graph Path ${JSON.stringify(path)} requires a walker.`);
-        this.path = path;
-        this.name = 'GraphPathWalkerRequiredError';
-    }
-}

package/dist/graph/graph/navigation/index.d.ts

@@ -1,2 +0,0 @@
-export type { GraphPathContext, GraphPathWalker } from './model.js';
-export { GraphPathAmbiguousError, GraphPathWalkerRequiredError } from './error.js';

package/dist/graph/graph/navigation/index.js

@@ -1 +0,0 @@
-export { GraphPathAmbiguousError, GraphPathWalkerRequiredError } from './error.js';

package/dist/graph/graph/navigation/model.d.ts

@@ -1,15 +0,0 @@
-import type { ClassKey } from '@astrale-os/kernel-dsl/v1/addressing';
-import type { EdgeOrientation } from '@astrale-os/kernel-dsl/v1/language';
-import type { Node } from '../../node/index.js';
-import type { Path } from '../../path/index.js';
-import type { GraphEdges, GraphNodes } from '../indexes/index.js';
-/** Semantic read-only graph capabilities available to a Path walker. */
-export interface GraphPathContext {
-    readonly nodes: GraphNodes;
-    readonly edges: GraphEdges;
-    orientation(classKey: ClassKey): EdgeOrientation | undefined;
-}
-/** Pure injected semantics for walking one Path against an admitted Graph. */
-export interface GraphPathWalker {
-    walk(path: Path, context: GraphPathContext): Node | undefined;
-}

package/dist/schema/callables/view-for.d.ts

@@ -1,296 +0,0 @@
-import { type builder } from '@astrale-os/kernel-dsl/v1';
-export declare const ViewFor: builder.DirectedEdgeClass<{
-    readonly abstract: false;
-    readonly source: {
-        readonly as: "view";
-        readonly accepts: readonly [builder.NodeClass<{
-            readonly abstract: false;
-            readonly description: "The installed projection of a declarative browser surface; it is not a principal.";
-            readonly extends: readonly [builder.NodeClass<{
-                readonly abstract: true;
-                readonly extends: readonly [builder.NodeClass<{
-                    readonly abstract: true;
-                    readonly description: "The abstract universal kernel Node Class extended by every Kernel Node Class.";
-                }>];
-                readonly description: "Optional human-facing description metadata with no identity or authority semantics.";
-                readonly properties: {
-                    description: builder.Property<Readonly<{
-                        readonly type: 'string';
-                        readonly minLength: 1;
-                        readonly maxLength: 1000;
-                    }>, {
-                        readonly required: false;
-                    }>;
-                };
-            }>];
-            readonly methods: Readonly<{
-                resolve: builder.Method<{
-                    readonly description: "Resolve the installed View declarations applicable to one authorized graph target.";
-                    readonly auth: "authorized";
-                    readonly input: import("zod").ZodObject<{
-                        target: import("zod").ZodString;
-                    }, import("zod/v4/core").$strict>;
-                    readonly output: import("zod").ZodObject<{
-                        snapshot: import("zod").ZodString;
-                        views: import("zod").ZodArray<import("zod").ZodObject<{
-                            key: import("zod").ZodString;
-                            declaration: import("zod").ZodObject<{
-                                description: import("zod").ZodOptional<import("zod").ZodString>;
-                                target: import("zod").ZodDiscriminatedUnion<[import("zod").ZodObject<{
-                                    kind: import("zod").ZodLiteral<"domain">;
-                                }, import("zod/v4/core").$strict>, import("zod").ZodObject<{
-                                    kind: import("zod").ZodLiteral<"definition">;
-                                    definitions: import("zod").ZodArray<import("zod").ZodObject<{
-                                        origin: import("zod").ZodString;
-                                        kind: import("zod").ZodLiteral<"class">;
-                                        name: import("zod").ZodString;
-                                    }, import("zod/v4/core").$strict>>;
-                                }, import("zod/v4/core").$strict>], "kind">;
-                            }, import("zod/v4/core").$strict>;
-                            href: import("zod").ZodString;
-                            handshake: import("zod").ZodEnum<{
-                                none: "none";
-                                shell: "shell";
-                            }>;
-                            issuer: import("zod").ZodString;
-                            etag: import("zod").ZodString;
-                            revision: import("zod").ZodString;
-                        }, import("zod/v4/core").$strict>>;
-                    }, import("zod/v4/core").$strict>;
-                    readonly static: true;
-                    readonly inheritance: "sealed";
-                }>;
-            }>;
-        }>];
-        readonly outgoing: "1..*";
-    };
-    readonly target: {
-        readonly as: "target";
-        readonly accepts: readonly [builder.NodeClass<{
-            readonly abstract: false;
-            readonly description: "The installed graph projection of a Node Class or Edge Class declaration.";
-            readonly extends: readonly [builder.NodeClass<{
-                readonly abstract: true;
-                readonly extends: readonly [builder.NodeClass<{
-                    readonly abstract: true;
-                    readonly description: "The abstract universal kernel Node Class extended by every Kernel Node Class.";
-                }>];
-                readonly description: "Optional human-facing description metadata with no identity or authority semantics.";
-                readonly properties: {
-                    description: builder.Property<Readonly<{
-                        readonly type: 'string';
-                        readonly minLength: 1;
-                        readonly maxLength: 1000;
-                    }>, {
-                        readonly required: false;
-                    }>;
-                };
-            }>, builder.NodeClass<{
-                readonly abstract: true;
-                readonly extends: readonly [builder.NodeClass<{
-                    readonly abstract: true;
-                    readonly description: "The abstract universal kernel Node Class extended by every Kernel Node Class.";
-                }>];
-                readonly description: "Optional bounded presentation icon metadata.";
-                readonly properties: {
-                    icon: builder.Property<Readonly<{
-                        readonly type: 'string';
-                        readonly minLength: 1;
-                        readonly maxLength: 8000;
-                    }>, {
-                        readonly required: false;
-                    }>;
-                };
-            }>];
-            readonly properties: {
-                readonly kind: {
-                    readonly enum: readonly ["node", "edge"];
-                };
-                readonly abstract: {
-                    readonly type: "boolean";
-                };
-            };
-        }>, builder.NodeClass<{
-            readonly abstract: false;
-            readonly description: "A stable Domain principal and the active projection of one canonical DomainSchema revision.";
-            readonly extends: readonly [builder.NodeClass<{
-                readonly abstract: true;
-                readonly description: "A principal that can be authenticated and can originate persistent authority facts.";
-                readonly extends: readonly [builder.NodeClass<{
-                    readonly abstract: true;
-                    readonly description: "The abstract universal kernel Node Class extended by every Kernel Node Class.";
-                }>];
-                readonly properties: {
-                    readonly frozen: builder.Property<{
-                        readonly type: "boolean";
-                    }, {
-                        readonly required: false;
-                        readonly visibility: "private";
-                    }>;
-                    readonly iss: {
-                        readonly type: "string";
-                        readonly minLength: 1;
-                    };
-                    readonly requiredClaims: builder.Property<import("zod").ZodArray<import("zod").ZodDiscriminatedUnion<[import("zod").ZodObject<{
-                        claim: import("zod").ZodString;
-                        op: import("zod").ZodLiteral<"contains">;
-                        value: import("zod").ZodNonOptional<import("zod").ZodUnknown>;
-                    }, import("zod/v4/core").$strict>, import("zod").ZodObject<{
-                        claim: import("zod").ZodString;
-                        op: import("zod").ZodLiteral<"eq">;
-                        value: import("zod").ZodNonOptional<import("zod").ZodUnknown>;
-                    }, import("zod/v4/core").$strict>, import("zod").ZodObject<{
-                        claim: import("zod").ZodString;
-                        op: import("zod").ZodLiteral<"exists">;
-                    }, import("zod/v4/core").$strict>], "op">>, {
-                        readonly required: false;
-                        readonly visibility: "private";
-                    }>;
-                    readonly sub: {
-                        readonly type: "string";
-                        readonly minLength: 1;
-                    };
-                };
-                readonly methods: Readonly<{
-                    delegate: builder.Method<{
-                        readonly description: "Issue one strictly attenuated credential from this authenticated Identity.";
-                        readonly auth: "authenticated";
-                        readonly input: import("zod").ZodObject<{
-                            audience: import("zod").ZodString;
-                            ttlSeconds: import("zod").ZodNumber;
-                            attenuation: import("zod").ZodUnknown;
-                        }, import("zod/v4/core").$strict>;
-                        readonly output: import("zod").ZodString;
-                        readonly inheritance: "default";
-                    }>;
-                    can: builder.Method<{
-                        readonly description: "Determine whether the current authenticated Identity satisfies one installed Policy for one object.";
-                        readonly auth: "authenticated";
-                        readonly input: import("zod").ZodObject<{
-                            policy: import("zod").ZodString;
-                            object: import("zod").ZodString;
-                        }, import("zod/v4/core").$strict>;
-                        readonly output: import("zod").ZodObject<{
-                            allowed: import("zod").ZodBoolean;
-                        }, import("zod/v4/core").$strict>;
-                        readonly static: true;
-                        readonly inheritance: "default";
-                    }>;
-                    whoami: builder.Method<{
-                        readonly description: "Return the Identity authenticated for this invocation.";
-                        readonly auth: "authenticated";
-                        readonly input: import("zod").ZodObject<{}, import("zod/v4/core").$strict>;
-                        readonly output: import("zod").ZodObject<{
-                            id: import("zod").ZodString;
-                            issuer: import("zod").ZodString;
-                            subject: import("zod").ZodString;
-                            frozen: import("zod").ZodBoolean;
-                            requiredClaims: import("zod").ZodArray<import("zod").ZodDiscriminatedUnion<[import("zod").ZodObject<{
-                                claim: import("zod").ZodString;
-                                op: import("zod").ZodLiteral<"contains">;
-                                value: import("zod").ZodNonOptional<import("zod").ZodUnknown>;
-                            }, import("zod/v4/core").$strict>, import("zod").ZodObject<{
-                                claim: import("zod").ZodString;
-                                op: import("zod").ZodLiteral<"eq">;
-                                value: import("zod").ZodNonOptional<import("zod").ZodUnknown>;
-                            }, import("zod/v4/core").$strict>, import("zod").ZodObject<{
-                                claim: import("zod").ZodString;
-                                op: import("zod").ZodLiteral<"exists">;
-                            }, import("zod/v4/core").$strict>], "op">>;
-                        }, import("zod/v4/core").$strict>;
-                        readonly static: true;
-                        readonly inheritance: "default";
-                    }>;
-                    whois: builder.Method<{
-                        readonly description: "Resolve one issuer-and-subject Identity.";
-                        readonly auth: "authorized";
-                        readonly input: import("zod").ZodObject<{
-                            issuer: import("zod").ZodString;
-                            subject: import("zod").ZodString;
-                        }, import("zod/v4/core").$strict>;
-                        readonly output: import("zod").ZodNullable<import("zod").ZodObject<{
-                            id: import("zod").ZodString;
-                            issuer: import("zod").ZodString;
-                            subject: import("zod").ZodString;
-                            frozen: import("zod").ZodBoolean;
-                            requiredClaims: import("zod").ZodArray<import("zod").ZodDiscriminatedUnion<[import("zod").ZodObject<{
-                                claim: import("zod").ZodString;
-                                op: import("zod").ZodLiteral<"contains">;
-                                value: import("zod").ZodNonOptional<import("zod").ZodUnknown>;
-                            }, import("zod/v4/core").$strict>, import("zod").ZodObject<{
-                                claim: import("zod").ZodString;
-                                op: import("zod").ZodLiteral<"eq">;
-                                value: import("zod").ZodNonOptional<import("zod").ZodUnknown>;
-                            }, import("zod/v4/core").$strict>, import("zod").ZodObject<{
-                                claim: import("zod").ZodString;
-                                op: import("zod").ZodLiteral<"exists">;
-                            }, import("zod/v4/core").$strict>], "op">>;
-                        }, import("zod/v4/core").$strict>>;
-                        readonly static: true;
-                        readonly inheritance: "default";
-                    }>;
-                    mint: builder.Method<{
-                        readonly description: "Resolve and sign one authorized Grant credential.";
-                        readonly auth: "authorized";
-                        readonly input: import("zod").ZodObject<{
-                            audience: import("zod").ZodOptional<import("zod").ZodString>;
-                            ttlSeconds: import("zod").ZodNumber;
-                            grant: import("zod").ZodOptional<import("zod").ZodUnknown>;
-                        }, import("zod/v4/core").$strict>;
-                        readonly output: import("zod").ZodString;
-                        readonly static: true;
-                        readonly inheritance: "default";
-                    }>;
-                }>;
-            }>];
-            readonly properties: {
-                readonly origin: {
-                    readonly type: "string";
-                    readonly pattern: "[a-z0-9]([a-z0-9-]{0,61}[a-z0-9])?(\\.[a-z0-9]([a-z0-9-]{0,61}[a-z0-9])?)+";
-                };
-                readonly dependencyContext: builder.Property<{
-                    readonly type: "array";
-                    readonly items: {
-                        readonly type: "object";
-                    };
-                }, {
-                    readonly visibility: "private";
-                    readonly required: false;
-                }>;
-                readonly schema: builder.Property<{
-                    readonly type: "object";
-                }, {
-                    readonly visibility: "private";
-                }>;
-                readonly schemaRevision: builder.Property<{
-                    readonly type: "string";
-                    readonly pattern: "sha256:[0-9a-f]{64}";
-                }, {
-                    readonly visibility: "private";
-                }>;
-            };
-        }>];
-        readonly incoming: "0..*";
-    };
-    readonly description: "A View declaration targets one Domain or a non-empty set of Classes.";
-    readonly extends: readonly [builder.DirectedEdgeClass<{
-        readonly abstract: true;
-        readonly source: {
-            readonly as: "source";
-            readonly accepts: readonly [builder.NodeClass<{
-                readonly abstract: true;
-                readonly description: "The abstract universal kernel Node Class extended by every Kernel Node Class.";
-            }>];
-            readonly outgoing: "0..*";
-        };
-        readonly target: {
-            readonly as: "target";
-            readonly accepts: readonly [builder.NodeClass<{
-                readonly abstract: true;
-                readonly description: "The abstract universal kernel Node Class extended by every Kernel Node Class.";
-            }>];
-            readonly incoming: "0..*";
-        };
-        readonly description: "Explicit kernel marker for Edge definitions; it carries no structural fields.";
-    }>];
-}>;