@astrale-domains/shell 0.1.0-beta.9 → 0.1.2

package/dist/schema/modules/user/functions/invite-user.js

@@ -0,0 +1,12 @@
+import { method, path } from '@astrale-os/sdk/schema';
+import { z } from 'zod';
+import { ownsClass, administersShellClass } from '../../../policies/index.js';
+import { User } from '../classes/index.js';
+import { invitationSummary } from '../types/index.js';
+export const invite = method({
+    static: true,
+    auth: 'authorized',
+    input: z.object({ user: path(() => User), email: z.string().min(3).max(320) }),
+    output: invitationSummary,
+    policy: ({ anyOf, check, input }) => anyOf(check(administersShellClass, input.user), check(ownsClass, input.user)),
+});

package/dist/schema/modules/user/functions/record-profile.js

@@ -0,0 +1,14 @@
+import { method } from '@astrale-os/sdk/schema';
+import { z } from 'zod';
+import { isSelf } from '../../../policies/index.js';
+import { userDisplayName, userEmail } from '../types/index.js';
+export const recordProfile = method({
+    description: 'Record the email and display name this account signs in with; only the account itself may.',
+    auth: 'authorized',
+    input: z.strictObject({
+        email: userEmail.optional(),
+        displayName: userDisplayName.optional(),
+    }),
+    output: z.object({}),
+    policy: ({ check, self }) => check(isSelf, self),
+});

package/dist/schema/modules/user/index.d.ts

@@ -0,0 +1,2 @@
+export { User } from './classes/index.js';
+export { invitationSummary, type InvitationSummary } from './types/index.js';

package/dist/schema/modules/user/index.js

@@ -0,0 +1,2 @@
+export { User } from './classes/index.js';
+export { invitationSummary } from './types/index.js';

package/dist/schema/modules/user/types/index.d.ts

@@ -0,0 +1,2 @@
+export { invitationSummary, type InvitationSummary } from './invitation-summary.js';
+export { userEmail, userDisplayName } from './user-profile.js';

package/dist/schema/modules/user/types/index.js

@@ -0,0 +1,2 @@
+export { invitationSummary } from './invitation-summary.js';
+export { userEmail, userDisplayName } from './user-profile.js';

package/dist/schema/modules/user/types/invitation-summary.d.ts

@@ -0,0 +1,16 @@
+import { z } from 'zod';
+export declare const invitationSummary: z.ZodObject<{
+    invitationId: z.ZodString;
+    user: z.ZodString;
+    state: z.ZodEnum<{
+        accepted: "accepted";
+        cancelled: "cancelled";
+        completed: "completed";
+        expired: "expired";
+        failed: "failed";
+        pending: "pending";
+        registered: "registered";
+        registering: "registering";
+    }>;
+}, z.core.$strip>;
+export type InvitationSummary = z.infer<typeof invitationSummary>;

package/dist/schema/modules/user/types/invitation-summary.js

@@ -0,0 +1,15 @@
+import { z } from 'zod';
+export const invitationSummary = z.object({
+    invitationId: z.string().min(1),
+    user: z.string().min(1),
+    state: z.enum([
+        'pending',
+        'accepted',
+        'registering',
+        'registered',
+        'completed',
+        'cancelled',
+        'expired',
+        'failed',
+    ]),
+});

package/dist/schema/modules/user/types/user-profile.d.ts

@@ -0,0 +1,7 @@
+import { z } from 'zod';
+/**
+ * What an account says about itself, to be recognised in the directory: its sign-in email and its
+ * name. The account writes them, so they name it for display and decide nothing.
+ */
+export declare const userEmail: z.ZodString;
+export declare const userDisplayName: z.ZodString;

package/dist/schema/modules/user/types/user-profile.js

@@ -0,0 +1,7 @@
+import { z } from 'zod';
+/**
+ * What an account says about itself, to be recognised in the directory: its sign-in email and its
+ * name. The account writes them, so they name it for display and decide nothing.
+ */
+export const userEmail = z.string().min(3).max(320);
+export const userDisplayName = z.string().min(1).max(200);

package/dist/schema/modules/view-access/classes/index.d.ts

@@ -0,0 +1 @@
+export { view_access } from './view-access.js';

package/dist/schema/modules/view-access/classes/index.js

@@ -0,0 +1 @@
+export { view_access } from './view-access.js';

package/dist/schema/modules/view-access/classes/view-access.d.ts

@@ -0,0 +1,32 @@
+/**
+ * One View given to an account or a group: the holder, and each member of a holding group, has this
+ * View among the ones it opens. It decides navigation, never data: the View's own Domain still
+ * guards everything it shows. Only instance administrators create or delete it. The target is a
+ * Class Shell does not own, so the Edge detaches with its View.
+ */
+export declare const view_access: import("@astrale-os/sdk/schema").DirectedEdgeClass<{
+    readonly depth: 0;
+    readonly abstract: false;
+    readonly extends: readonly [];
+    readonly properties: never;
+    readonly source: {
+        readonly as: "holder";
+        readonly accepts: readonly (() => {
+            readonly kind: 'node';
+            readonly abstract: never;
+            readonly depth: never;
+            readonly properties: never;
+            readonly methods: never;
+        })[];
+        readonly outgoing: "0..*";
+    };
+    readonly target: {
+        readonly as: "view";
+        readonly accepts: readonly (import("@astrale-os/sdk/schema").ClassRef<"View"> & {
+            readonly origin: "kernel.astrale.ai";
+        })[];
+        readonly incoming: "0..*";
+    };
+    readonly constraints: Record<never, never>;
+    readonly effectiveProperties: never;
+}>;

package/dist/schema/modules/view-access/classes/view-access.js

@@ -0,0 +1,18 @@
+import { K, edgeClass } from '@astrale-os/sdk/schema';
+import { Group } from '../../group/index.js';
+import { User } from '../../user/index.js';
+/**
+ * One View given to an account or a group: the holder, and each member of a holding group, has this
+ * View among the ones it opens. It decides navigation, never data: the View's own Domain still
+ * guards everything it shows. Only instance administrators create or delete it. The target is a
+ * Class Shell does not own, so the Edge detaches with its View.
+ */
+export const view_access = edgeClass.directed({
+    policies: { read: true, traverse: true },
+    source: {
+        as: 'holder',
+        accepts: [() => User, () => Group],
+        outgoing: '0..*',
+    },
+    target: { as: 'view', accepts: [K.classes.View], incoming: '0..*' },
+});

package/dist/schema/modules/view-access/core/index.d.ts

@@ -0,0 +1 @@
+export { viewOnlyGroup } from './view-only-group.js';

package/dist/schema/modules/view-access/core/index.js

@@ -0,0 +1 @@
+export { viewOnlyGroup } from './view-only-group.js';

package/dist/schema/modules/view-access/core/view-only-group.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Its members open only the Views given to them, never the workspace. Administrators keep the
+ * workspace even when they are members.
+ */
+export declare const viewOnlyGroup: import("@astrale-os/sdk/schema").CoreNode;

package/dist/schema/modules/view-access/core/view-only-group.js

@@ -0,0 +1,10 @@
+import { K, core } from '@astrale-os/sdk/schema';
+import { Group } from '../../group/index.js';
+/**
+ * Its members open only the Views given to them, never the workspace. Administrators keep the
+ * workspace even when they are members.
+ */
+export const viewOnlyGroup = core.node(() => Group, {
+    [K.classes.Named.properties.name.key]: 'View only',
+    [K.classes.Descriptable.properties.description.key]: 'Open only the Views given to them, never the workspace.',
+});

package/dist/schema/modules/view-access/functions/assign-views.d.ts

@@ -0,0 +1,16 @@
+import { type Function as SchemaFunction } from '@astrale-os/sdk/schema';
+/**
+ * Give Views to identities and withdraw others, in one write. Each identity is a User or a Group;
+ * a View already given, or already withdrawn, stays as it is. Whether an identity opens the
+ * workspace is its `view-only` membership, which `Group.assignMember` changes.
+ */
+export declare const assignViews: SchemaFunction<import("@astrale-os/sdk/schema").CallableProjection<{
+    assignments: {
+        identity: string;
+        set?: string[] | undefined;
+        unset?: string[] | undefined;
+    }[];
+}, {
+    readonly mode: 'value';
+    readonly value: Record<string, never>;
+}, "authorized", false, false, undefined, undefined>>;

package/dist/schema/modules/view-access/functions/assign-views.js

@@ -0,0 +1,17 @@
+import { func } from '@astrale-os/sdk/schema';
+import { z } from 'zod';
+import { usesFunction } from '../../../policies/index.js';
+import { MAX_ASSIGNMENTS, viewAssignment } from '../types/index.js';
+/**
+ * Give Views to identities and withdraw others, in one write. Each identity is a User or a Group;
+ * a View already given, or already withdrawn, stays as it is. Whether an identity opens the
+ * workspace is its `view-only` membership, which `Group.assignMember` changes.
+ */
+export const assignViews = func({
+    description: 'Give and withdraw Views for each identity, in one write.',
+    auth: 'authorized',
+    input: z.strictObject({ assignments: z.array(viewAssignment).min(1).max(MAX_ASSIGNMENTS) }),
+    output: z.object({}),
+    // Holding can_use is enough: Core admin holds it, and may share it.
+    policy: ({ check, ref }) => check(usesFunction, ref(() => assignViews)),
+});

package/dist/schema/modules/view-access/functions/index.d.ts

@@ -0,0 +1 @@
+export { assignViews } from './assign-views.js';

package/dist/schema/modules/view-access/functions/index.js

@@ -0,0 +1 @@
+export { assignViews } from './assign-views.js';

package/dist/schema/modules/view-access/index.d.ts

@@ -0,0 +1,3 @@
+export { view_access } from './classes/index.js';
+export { viewOnlyGroup } from './core/index.js';
+export { assignViews } from './functions/index.js';

package/dist/schema/modules/view-access/index.js

@@ -0,0 +1,3 @@
+export { view_access } from './classes/index.js';
+export { viewOnlyGroup } from './core/index.js';
+export { assignViews } from './functions/index.js';

package/dist/schema/modules/view-access/types/index.js

@@ -0,0 +1 @@
+export { viewAssignment, MAX_ASSIGNED_VIEWS, MAX_ASSIGNMENTS } from './view-assignment.js';

package/dist/schema/modules/view-access/types/view-assignment.js

@@ -0,0 +1,16 @@
+import { z } from 'zod';
+/**
+ * Bounds that keep one call within the Kernel's Mutation limits: at most 1,600 Edge operations
+ * and 1,640 locators, under 2,048 each.
+ */
+export const MAX_ASSIGNED_VIEWS = 20;
+export const MAX_ASSIGNMENTS = 40;
+// A Path inside a list is not a callable Path input: each is an exact @NodeId the Action checks.
+const nodeId = z.string().min(2).max(512);
+const views = z.array(nodeId).max(MAX_ASSIGNED_VIEWS);
+/** The Views given to one User or Group (`set`) and withdrawn from it (`unset`), by @NodeId. */
+export const viewAssignment = z.strictObject({
+    identity: nodeId,
+    set: views.optional(),
+    unset: views.optional(),
+});

package/dist/schema/policies/administers-shell-class.js

@@ -0,0 +1,11 @@
+import { K, policy } from '@astrale-os/sdk/schema';
+import { Group, member_of_group, adminGroup } from '../modules/group/index.js';
+/** Instance administration applies to Shell's concrete classes, not foreign descendants. */
+export const administersShellClass = policy({
+    match: ({ exists, subject, object, ref, edge, allOf }) => exists(({ node }) => {
+        const concrete = node();
+        const owner = node(); // of_domain restricts this witness to a protected Domain endpoint.
+        const group = ref(() => Group);
+        return allOf(edge({ source: subject, class: () => member_of_group, target: ref(adminGroup) }), { source: ref(adminGroup), class: K.classes.instance_of.ref, target: group }, { source: group, class: K.classes.of_domain.ref, target: owner }, { source: concrete, class: K.classes.of_domain.ref, target: owner }, { source: object, class: K.classes.instance_of.ref, target: concrete });
+    }),
+});

package/dist/schema/policies/index.js

@@ -0,0 +1,4 @@
+export { ownsClass } from './owns-class.js';
+export { administersShellClass } from './administers-shell-class.js';
+export { usesFunction } from './uses-function.js';
+export { isSelf } from './is-self.js';

package/dist/schema/policies/is-self.js

@@ -0,0 +1,5 @@
+import { policy } from '@astrale-os/sdk/schema';
+/** The subject is the object itself: an account acting on its own Node. */
+export const isSelf = policy({
+    match: ({ sameNode, subject, object }) => sameNode(subject, object),
+});

package/dist/schema/policies/owns-class.js

@@ -0,0 +1,7 @@
+import { K, policy } from '@astrale-os/sdk/schema';
+export const ownsClass = policy({
+    match: ({ exists, subject, object, allOf }) => exists(({ node }) => {
+        const concrete = node(); // Périmètre défini par les deux edges kernel protégés.
+        return allOf({ source: object, class: K.classes.instance_of.ref, target: concrete }, { source: concrete, class: K.classes.of_domain.ref, target: subject });
+    }),
+});

package/dist/schema/policies/uses-function.js

@@ -0,0 +1,5 @@
+import { K, policy } from '@astrale-os/sdk/schema';
+/** The subject may use the object Function: its own or a composed Identity holds can_use on it. */
+export const usesFunction = policy({
+    match: ({ edge, subject, object }) => edge({ source: subject, class: () => K.classes.can_use, target: object }),
+});