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

package/dist/schema/callables/view-for.js

@@ -1,12 +0,0 @@
-import { edgeClass } from '@astrale-os/kernel-dsl/v1';
-import { Class } from '../definitions/index.js';
-import { Domain } from '../domain/index.js';
-import { Edge } from '../meta/index.js';
-import { View } from './view.js';
-export const ViewFor = edgeClass.directed({
-    abstract: false,
-    source: { as: 'view', accepts: [View], outgoing: '1..*' },
-    target: { as: 'target', accepts: [Class, Domain], incoming: '0..*' },
-    description: 'A View declaration targets one Domain or a non-empty set of Classes.',
-    extends: [Edge],
-});

package/dist/schema/kernel/projection/keys.d.ts

@@ -1,3 +0,0 @@
-import type { Domain } from '@astrale-os/kernel-dsl/v1';
-export declare function managedKeys(domain: Domain): readonly string[];
-export declare function coreKeys(domain: Domain): readonly string[];

package/dist/schema/kernel/projection/path.d.ts

@@ -1,2 +0,0 @@
-import type { GraphPathWalker } from '#graph/graph';
-export declare const projectionPathWalker: GraphPathWalker;

package/dist/schema/kernel/projection/path.js

@@ -1,140 +0,0 @@
-import { ClassKey } from '@astrale-os/kernel-dsl/v1/addressing';
-import { GraphPathAmbiguousError } from '#graph/graph';
-import { K } from '../index.js';
-export const projectionPathWalker = Object.freeze({
-    walk: walkProjectionPath,
-});
-function walkProjectionPath(path, context) {
-    let candidates = anchorCandidates(path.ast, context);
-    for (const step of path.ast.steps)
-        candidates = applyStep(candidates, step, context);
-    if (candidates.length === 0)
-        return undefined;
-    if (candidates.length === 1)
-        return candidates[0];
-    throw new GraphPathAmbiguousError(path.raw, candidates.length);
-}
-function anchorCandidates(ast, context) {
-    if (ast.anchor.kind === 'id') {
-        const node = context.nodes.byId(ast.anchor.id);
-        return node === undefined ? [] : [node];
-    }
-    const domainClass = ClassKey.of(K.classes.Domain.ref);
-    const origin = ast.anchor.origin;
-    return context.nodes
-        .byClass(domainClass)
-        .filter((node) => node.props[K.classes.Domain.properties.origin.key] === origin);
-}
-function applyStep(current, step, context) {
-    switch (step.kind) {
-        case 'projection':
-            return domainMembers(current, `${step.projection.kind}.${step.projection.name}`, context);
-        case 'method':
-            return step.dispatch === 'static'
-                ? directMethods(current, step.name, true, context)
-                : instanceMethods(current, step.name, context);
-        case 'traverse':
-            return traverse(current, step, context);
-    }
-}
-function domainMembers(domains, member, context) {
-    const domainIds = new Set(domains.map((node) => node.id));
-    return distinctNodes(edgesOf(K.classes.of_domain, context).flatMap((edge) => {
-        if (!domainIds.has(edge.target) ||
-            edge.props[K.classes.of_domain.properties.member.key] !== member) {
-            return [];
-        }
-        const node = context.nodes.byId(edge.source);
-        return node === undefined ? [] : [node];
-    }));
-}
-function directMethods(owners, name, isStatic, context) {
-    const ownerIds = new Set(owners.map((node) => node.id));
-    return distinctNodes(edgesOf(K.classes.method_of, context).flatMap((edge) => {
-        if (!ownerIds.has(edge.target) ||
-            edge.props[K.classes.method_of.properties.name.key] !== name ||
-            edge.props[K.classes.method_of.properties.static.key] !== isStatic) {
-            return [];
-        }
-        const method = context.nodes.byId(edge.source);
-        return method === undefined ? [] : [method];
-    }));
-}
-function instanceMethods(instances, name, context) {
-    return distinctNodes(instances.flatMap((instance) => {
-        const owner = resolveClassProjection(instance.class, context);
-        return owner.length === 0 ? [] : effectiveMethods(owner, name, context);
-    }));
-}
-function resolveClassProjection(key, context) {
-    const domainClass = ClassKey.of(K.classes.Domain.ref);
-    const domains = context.nodes
-        .byClass(domainClass)
-        .filter((node) => node.props[K.classes.Domain.properties.origin.key] === ClassKey.ref(key).origin);
-    return domainMembers(domains, `class.${ClassKey.ref(key).name}`, context);
-}
-/** Select the nearest declared Method in the valid Definition inheritance graph. */
-function effectiveMethods(roots, name, context) {
-    let level = distinctNodes(roots);
-    const visited = new Set();
-    while (level.length > 0) {
-        const fresh = level.filter((node) => !visited.has(node.id));
-        for (const node of fresh)
-            visited.add(node.id);
-        if (fresh.length === 0)
-            return [];
-        const methods = directMethods(fresh, name, false, context);
-        if (methods.length > 0)
-            return methods;
-        level = parentDefinitions(fresh, context);
-    }
-    return [];
-}
-function parentDefinitions(definitions, context) {
-    const ids = new Set(definitions.map((node) => node.id));
-    const relations = [K.classes.extends];
-    return distinctNodes(relations.flatMap((relation) => edgesOf(relation, context).flatMap((edge) => {
-        if (!ids.has(edge.source))
-            return [];
-        const parent = context.nodes.byId(edge.target);
-        return parent === undefined ? [] : [parent];
-    })));
-}
-function traverse(current, step, context) {
-    const currentIds = new Set(current.map((node) => node.id));
-    const edgeClass = step.class;
-    const orientation = context.orientation(edgeClass);
-    const candidates = context.edges.byClass(edgeClass);
-    return distinctNodes(candidates.flatMap((edge) => {
-        if (step.slug !== undefined && edge.slug !== step.slug)
-            return [];
-        const endpoint = traversedEndpoint(edge, currentIds, step.direction, orientation);
-        if (endpoint === undefined)
-            return [];
-        const node = context.nodes.byId(endpoint);
-        return node === undefined ? [] : [node];
-    }));
-}
-function traversedEndpoint(edge, current, direction, orientation) {
-    if (orientation === 'undirected') {
-        if (current.has(edge.source))
-            return edge.target;
-        if (current.has(edge.target))
-            return edge.source;
-        return undefined;
-    }
-    if (direction === 'out' && current.has(edge.source))
-        return edge.target;
-    if (direction === 'in' && current.has(edge.target))
-        return edge.source;
-    return undefined;
-}
-function edgesOf(relation, context) {
-    return context.edges.byClass(ClassKey.of(relation.ref));
-}
-function distinctNodes(nodes) {
-    const byId = new Map();
-    for (const node of nodes)
-        byId.set(node.id, node);
-    return [...byId.values()];
-}

package/dist/schema/kernel/syscalls/contracts/provision.d.ts

@@ -1,292 +0,0 @@
-import { z } from 'zod';
-export declare const provisionInput: z.ZodObject<{
-    idempotencyKey: z.ZodString;
-    mutation: z.ZodObject<{
-        format: z.ZodLiteral<"astrale.graph.mutation">;
-        version: z.ZodLiteral<"v3">;
-        preconditions: z.ZodArray<z.ZodUnion<readonly [z.ZodObject<{
-            kind: z.ZodLiteral<"node">;
-            node: z.ZodString;
-            class: z.ZodString;
-            props: z.ZodOptional<z.ZodUnion<readonly [z.ZodObject<{
-                equals: z.ZodRecord<z.ZodString, z.ZodUnknown>;
-                absent: z.ZodOptional<z.ZodArray<z.ZodString>>;
-            }, z.core.$strict>, z.ZodObject<{
-                absent: z.ZodArray<z.ZodString>;
-            }, z.core.$strict>]>>;
-        }, z.core.$strict>, z.ZodObject<{
-            kind: z.ZodLiteral<"edge">;
-            edge: z.ZodObject<{
-                source: z.ZodString;
-                target: z.ZodString;
-                class: z.ZodString;
-            }, z.core.$strict>;
-            slug: z.ZodOptional<z.ZodNullable<z.ZodType<import("../../../../graph/edge/index.js").EdgeSlug, unknown, z.core.$ZodTypeInternals<import("../../../../graph/edge/index.js").EdgeSlug, unknown>>>>;
-            props: z.ZodOptional<z.ZodUnion<readonly [z.ZodObject<{
-                equals: z.ZodRecord<z.ZodString, z.ZodUnknown>;
-                absent: z.ZodOptional<z.ZodArray<z.ZodString>>;
-            }, z.core.$strict>, z.ZodObject<{
-                absent: z.ZodArray<z.ZodString>;
-            }, z.core.$strict>]>>;
-        }, z.core.$strict>, z.ZodObject<{
-            kind: z.ZodLiteral<"query">;
-            query: z.ZodObject<{
-                format: z.ZodLiteral<"astrale.graph.query">;
-                version: z.ZodLiteral<"v6">;
-                source: z.ZodDiscriminatedUnion<[z.ZodObject<{
-                    kind: z.ZodLiteral<"node">;
-                    terms: z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
-                        kind: z.ZodLiteral<"path">;
-                        path: z.ZodString;
-                    }, z.core.$strict>, z.ZodObject<{
-                        kind: z.ZodLiteral<"class">;
-                        class: z.ZodObject<{
-                            origin: z.ZodString;
-                            kind: z.ZodLiteral<"class">;
-                            name: z.ZodString;
-                        }, z.core.$strict>;
-                    }, z.core.$strict>], "kind">>;
-                    binding: z.ZodString;
-                }, z.core.$strict>, z.ZodObject<{
-                    kind: z.ZodLiteral<"edge">;
-                    terms: z.ZodArray<z.ZodObject<{
-                        kind: z.ZodLiteral<"class">;
-                        class: z.ZodObject<{
-                            origin: z.ZodString;
-                            kind: z.ZodLiteral<"class">;
-                            name: z.ZodString;
-                        }, z.core.$strict>;
-                    }, z.core.$strict>>;
-                    bindings: z.ZodObject<{
-                        source: z.ZodString;
-                        edge: z.ZodString;
-                        target: z.ZodString;
-                    }, z.core.$strict>;
-                }, z.core.$strict>], "kind">;
-                steps: z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
-                    op: z.ZodLiteral<"filter">;
-                    binding: z.ZodString;
-                    predicate: z.ZodDiscriminatedUnion<[z.ZodObject<{
-                        kind: z.ZodLiteral<"class.satisfies">;
-                        class: z.ZodObject<{
-                            origin: z.ZodString;
-                            kind: z.ZodLiteral<"class">;
-                            name: z.ZodString;
-                        }, z.core.$strict>;
-                    }, z.core.$strict>, z.ZodObject<{
-                        kind: z.ZodLiteral<"class.equal">;
-                        class: z.ZodObject<{
-                            origin: z.ZodString;
-                            kind: z.ZodLiteral<"class">;
-                            name: z.ZodString;
-                        }, z.core.$strict>;
-                    }, z.core.$strict>, z.ZodObject<{
-                        kind: z.ZodLiteral<"property.equal">;
-                        property: z.ZodString;
-                        value: z.ZodUnknown;
-                    }, z.core.$strict>, z.ZodObject<{
-                        kind: z.ZodLiteral<"property.present">;
-                        property: z.ZodString;
-                    }, z.core.$strict>, z.ZodObject<{
-                        kind: z.ZodLiteral<"identity.equal">;
-                        identity: z.ZodUnion<readonly [z.ZodString, z.ZodObject<{
-                            source: z.ZodString;
-                            target: z.ZodString;
-                            class: z.ZodString;
-                        }, z.core.$strict>]>;
-                    }, z.core.$strict>], "kind">;
-                }, z.core.$strict>, z.ZodObject<{
-                    op: z.ZodLiteral<"expand">;
-                    from: z.ZodString;
-                    via: z.ZodArray<z.ZodObject<{
-                        origin: z.ZodString;
-                        kind: z.ZodLiteral<"class">;
-                        name: z.ZodString;
-                    }, z.core.$strict>>;
-                    direction: z.ZodEnum<{
-                        incident: "incident";
-                        incoming: "incoming";
-                        outgoing: "outgoing";
-                    }>;
-                    bindings: z.ZodObject<{
-                        edge: z.ZodString;
-                        node: z.ZodString;
-                    }, z.core.$strict>;
-                }, z.core.$strict>], "op">>;
-                select: z.ZodDiscriminatedUnion<[z.ZodObject<{
-                    kind: z.ZodLiteral<"graph">;
-                    binding: z.ZodString;
-                    order: z.ZodOptional<z.ZodObject<{
-                        property: z.ZodString;
-                        direction: z.ZodEnum<{
-                            asc: "asc";
-                            desc: "desc";
-                        }>;
-                        unranked: z.ZodEnum<{
-                            first: "first";
-                            last: "last";
-                        }>;
-                    }, z.core.$strict>>;
-                }, z.core.$strict>, z.ZodObject<{
-                    kind: z.ZodLiteral<"nodes">;
-                    binding: z.ZodString;
-                    projection: z.ZodObject<{
-                        kind: z.ZodEnum<{
-                            reference: "reference";
-                            value: "value";
-                        }>;
-                    }, z.core.$strict>;
-                    order: z.ZodOptional<z.ZodObject<{
-                        property: z.ZodString;
-                        direction: z.ZodEnum<{
-                            asc: "asc";
-                            desc: "desc";
-                        }>;
-                        unranked: z.ZodEnum<{
-                            first: "first";
-                            last: "last";
-                        }>;
-                    }, z.core.$strict>>;
-                }, z.core.$strict>, z.ZodObject<{
-                    kind: z.ZodLiteral<"edges">;
-                    binding: z.ZodString;
-                    projection: z.ZodObject<{
-                        edge: z.ZodEnum<{
-                            reference: "reference";
-                            value: "value";
-                        }>;
-                        source: z.ZodEnum<{
-                            reference: "reference";
-                            value: "value";
-                        }>;
-                        target: z.ZodEnum<{
-                            reference: "reference";
-                            value: "value";
-                        }>;
-                    }, z.core.$strict>;
-                    order: z.ZodOptional<z.ZodObject<{
-                        property: z.ZodString;
-                        direction: z.ZodEnum<{
-                            asc: "asc";
-                            desc: "desc";
-                        }>;
-                        unranked: z.ZodEnum<{
-                            first: "first";
-                            last: "last";
-                        }>;
-                    }, z.core.$strict>>;
-                }, z.core.$strict>], "kind">;
-            }, z.core.$strict>;
-            equals: z.ZodDiscriminatedUnion<[z.ZodObject<{
-                kind: z.ZodLiteral<"node">;
-                ids: z.ZodArray<z.ZodString>;
-            }, z.core.$strict>, z.ZodObject<{
-                kind: z.ZodLiteral<"edge">;
-                keys: z.ZodArray<z.ZodObject<{
-                    source: z.ZodString;
-                    target: z.ZodString;
-                    class: z.ZodString;
-                }, z.core.$strict>>;
-            }, z.core.$strict>], "kind">;
-        }, z.core.$strict>]>>;
-        operations: z.ZodArray<z.ZodUnion<readonly [z.ZodObject<{
-            op: z.ZodLiteral<"node.create">;
-            as: z.ZodString;
-            class: z.ZodString;
-            props: z.ZodRecord<z.ZodString, z.ZodUnknown>;
-        }, z.core.$strict>, z.ZodObject<{
-            op: z.ZodLiteral<"node.update">;
-            node: z.ZodString;
-            class: z.ZodString;
-            props: z.ZodObject<{
-                set: z.ZodRecord<z.ZodString, z.ZodUnknown>;
-                unset: z.ZodArray<z.ZodString>;
-            }, z.core.$strict>;
-        }, z.core.$strict>, z.ZodObject<{
-            op: z.ZodLiteral<"node.delete">;
-            node: z.ZodString;
-            class: z.ZodString;
-        }, z.core.$strict>, z.ZodObject<{
-            op: z.ZodLiteral<"edge.create">;
-            class: z.ZodString;
-            source: z.ZodUnion<readonly [z.ZodString, z.ZodObject<{
-                created: z.ZodString;
-            }, z.core.$strict>]>;
-            target: z.ZodUnion<readonly [z.ZodString, z.ZodObject<{
-                created: z.ZodString;
-            }, z.core.$strict>]>;
-            slug: z.ZodOptional<z.ZodType<import("../../../../graph/edge/index.js").EdgeSlug, unknown, z.core.$ZodTypeInternals<import("../../../../graph/edge/index.js").EdgeSlug, unknown>>>;
-            props: z.ZodRecord<z.ZodString, z.ZodUnknown>;
-        }, z.core.$strict>, z.ZodObject<{
-            op: z.ZodLiteral<"edge.update">;
-            edge: z.ZodObject<{
-                source: z.ZodString;
-                target: z.ZodString;
-                class: z.ZodString;
-            }, z.core.$strict>;
-            slug: z.ZodNullable<z.ZodType<import("../../../../graph/edge/index.js").EdgeSlug, unknown, z.core.$ZodTypeInternals<import("../../../../graph/edge/index.js").EdgeSlug, unknown>>>;
-            props: z.ZodOptional<z.ZodObject<{
-                set: z.ZodRecord<z.ZodString, z.ZodUnknown>;
-                unset: z.ZodArray<z.ZodString>;
-            }, z.core.$strict>>;
-        }, z.core.$strict>, z.ZodObject<{
-            op: z.ZodLiteral<"edge.update">;
-            edge: z.ZodObject<{
-                source: z.ZodString;
-                target: z.ZodString;
-                class: z.ZodString;
-            }, z.core.$strict>;
-            props: z.ZodObject<{
-                set: z.ZodRecord<z.ZodString, z.ZodUnknown>;
-                unset: z.ZodArray<z.ZodString>;
-            }, z.core.$strict>;
-        }, z.core.$strict>, z.ZodObject<{
-            op: z.ZodLiteral<"edge.delete">;
-            edge: z.ZodObject<{
-                source: z.ZodString;
-                target: z.ZodString;
-                class: z.ZodString;
-            }, z.core.$strict>;
-        }, z.core.$strict>]>>;
-    }, z.core.$strict>;
-    identities: z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodObject<{
-        issuer: z.ZodString;
-        subject: z.ZodString;
-        requiredClaims: z.ZodOptional<z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
-            claim: z.ZodString;
-            op: z.ZodLiteral<"contains">;
-            value: z.ZodNonOptional<z.ZodUnknown>;
-        }, z.core.$strict>, z.ZodObject<{
-            claim: z.ZodString;
-            op: z.ZodLiteral<"eq">;
-            value: z.ZodNonOptional<z.ZodUnknown>;
-        }, z.core.$strict>, z.ZodObject<{
-            claim: z.ZodString;
-            op: z.ZodLiteral<"exists">;
-        }, z.core.$strict>], "op">>>;
-    }, z.core.$strict>, z.ZodObject<{
-        credentials: z.ZodObject<{
-            publicKey: z.ZodUnknown;
-            proof: z.ZodString;
-        }, z.core.$strict>;
-        requiredClaims: z.ZodOptional<z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
-            claim: z.ZodString;
-            op: z.ZodLiteral<"contains">;
-            value: z.ZodNonOptional<z.ZodUnknown>;
-        }, z.core.$strict>, z.ZodObject<{
-            claim: z.ZodString;
-            op: z.ZodLiteral<"eq">;
-            value: z.ZodNonOptional<z.ZodUnknown>;
-        }, z.core.$strict>, z.ZodObject<{
-            claim: z.ZodString;
-            op: z.ZodLiteral<"exists">;
-        }, z.core.$strict>], "op">>>;
-    }, z.core.$strict>]>>;
-}, z.core.$strict>;
-export declare const provisionOutput: z.ZodObject<{
-    createdNodes: z.ZodRecord<z.ZodString, z.ZodString>;
-    identities: z.ZodRecord<z.ZodString, z.ZodObject<{
-        issuer: z.ZodString;
-        subject: z.ZodString;
-    }, z.core.$strict>>;
-}, z.core.$strict>;

package/dist/schema/kernel/syscalls/contracts/provision.js

@@ -1,19 +0,0 @@
-import { z } from 'zod';
-import { mutationAstSchema } from '#graph/mutate/wire';
-import { requiredClaimsSchema } from '../../../authority/claims.js';
-const text = z.string().min(1);
-const requiredClaims = requiredClaimsSchema.optional();
-const asserted = z.strictObject({ issuer: text, subject: text, requiredClaims });
-const self = z.strictObject({
-    credentials: z.strictObject({ publicKey: z.unknown(), proof: text }),
-    requiredClaims,
-});
-export const provisionInput = z.strictObject({
-    idempotencyKey: text,
-    mutation: mutationAstSchema,
-    identities: z.record(z.string(), z.union([asserted, self])),
-});
-export const provisionOutput = z.strictObject({
-    createdNodes: z.record(z.string(), text),
-    identities: z.record(z.string(), z.strictObject({ issuer: text, subject: text })),
-});

package/dist/schema/kernel/syscalls/declarations/define.d.ts

@@ -1,5 +0,0 @@
-import { type builder } from '@astrale-os/kernel-dsl/v1';
-export type SyscallFunctionDefinition = builder.FunctionInput;
-export type SyscallMethodDefinition = builder.MethodInput;
-export declare function defineFunction<const Config extends SyscallFunctionDefinition>(config: Config): builder.Function<Config>;
-export declare function defineMethod<const Config extends SyscallMethodDefinition>(config: Config): builder.Method<Config>;

package/dist/schema/kernel/syscalls/declarations/define.js

@@ -1,7 +0,0 @@
-import { func, method } from '@astrale-os/kernel-dsl/v1';
-export function defineFunction(config) {
-    return func(config);
-}
-export function defineMethod(config) {
-    return method(config);
-}