@astrale-domains/issues 0.1.3 → 0.1.4

package/dist/schema/modules/issue/functions/add-issue-comment.d.ts

@@ -0,0 +1,9 @@
+export declare const addIssueCommentMethod: import("@astrale-os/sdk/schema").Method<import("@astrale-os/sdk/schema").CallableProjection<{
+    body: string;
+}, {
+    readonly mode: 'value';
+    readonly value: {
+        id: string;
+        body: string;
+    };
+}, "authorized", false, "default">>;

package/dist/schema/modules/issue/functions/add-issue-comment.js

@@ -0,0 +1,11 @@
+import { method } from '@astrale-os/sdk/schema';
+import { z } from 'zod';
+import { commentValue } from '../../comment/index.js';
+import { ContributeToIssue } from '../policies/contribute-to-issue.js';
+export const addIssueCommentMethod = method({
+    description: 'Add one authored Comment to this Issue.',
+    auth: 'authorized',
+    policy: ({ check, self }) => check(ContributeToIssue, self),
+    input: z.strictObject({ body: z.string().min(1).max(50_000) }),
+    output: commentValue,
+});

package/dist/schema/modules/issue/functions/archive-issue.d.ts

@@ -0,0 +1,7 @@
+export declare const archiveIssueMethod: import("@astrale-os/sdk/schema").Method<import("@astrale-os/sdk/schema").CallableProjection<Record<string, never>, {
+    readonly mode: 'value';
+    readonly value: {
+        issueId: string;
+        archived: true;
+    };
+}, "authorized", false, "default">>;

package/dist/schema/modules/issue/functions/archive-issue.js

@@ -0,0 +1,11 @@
+import { method } from '@astrale-os/sdk/schema';
+import { z } from 'zod';
+import { nodeIdValue } from '../../../types/index.js';
+import { ContributeToIssue } from '../policies/contribute-to-issue.js';
+export const archiveIssueMethod = method({
+    description: 'Archive this Issue without deleting its discussion or relationships.',
+    auth: 'authorized',
+    policy: ({ check, self }) => check(ContributeToIssue, self),
+    input: z.strictObject({}),
+    output: z.strictObject({ issueId: nodeIdValue, archived: z.literal(true) }),
+});

package/dist/schema/modules/issue/functions/assign-issue.d.ts

@@ -0,0 +1,9 @@
+export declare const assignIssueMethod: import("@astrale-os/sdk/schema").Method<import("@astrale-os/sdk/schema").CallableProjection<{
+    assigneeId: string | null;
+}, {
+    readonly mode: 'value';
+    readonly value: {
+        issueId: string;
+        assigneeId?: string | undefined;
+    };
+}, "authorized", false, "default">>;

package/dist/schema/modules/issue/functions/assign-issue.js

@@ -0,0 +1,11 @@
+import { method } from '@astrale-os/sdk/schema';
+import { z } from 'zod';
+import { nodeIdValue } from '../../../types/index.js';
+import { ContributeToIssue } from '../policies/contribute-to-issue.js';
+export const assignIssueMethod = method({
+    description: 'Assign this Issue to a Project participant or clear its assignee.',
+    auth: 'authorized',
+    policy: ({ check, self }) => check(ContributeToIssue, self),
+    input: z.strictObject({ assigneeId: nodeIdValue.nullable() }),
+    output: z.strictObject({ issueId: nodeIdValue, assigneeId: nodeIdValue.optional() }),
+});

package/dist/schema/modules/issue/functions/index.d.ts

@@ -0,0 +1,7 @@
+export { addIssueCommentMethod } from './add-issue-comment.js';
+export { archiveIssueMethod } from './archive-issue.js';
+export { assignIssueMethod } from './assign-issue.js';
+export { setIssueParentMethod } from './set-issue-parent.js';
+export { setIssueTagsMethod } from './set-issue-tags.js';
+export { transitionIssueMethod } from './transition-issue.js';
+export { updateIssueMethod } from './update-issue.js';

package/dist/schema/modules/issue/functions/index.js

@@ -0,0 +1,7 @@
+export { addIssueCommentMethod } from './add-issue-comment.js';
+export { archiveIssueMethod } from './archive-issue.js';
+export { assignIssueMethod } from './assign-issue.js';
+export { setIssueParentMethod } from './set-issue-parent.js';
+export { setIssueTagsMethod } from './set-issue-tags.js';
+export { transitionIssueMethod } from './transition-issue.js';
+export { updateIssueMethod } from './update-issue.js';

package/dist/schema/modules/issue/functions/set-issue-parent.d.ts

@@ -0,0 +1,9 @@
+export declare const setIssueParentMethod: import("@astrale-os/sdk/schema").Method<import("@astrale-os/sdk/schema").CallableProjection<{
+    parentId: string | null;
+}, {
+    readonly mode: 'value';
+    readonly value: {
+        issueId: string;
+        parentId?: string | undefined;
+    };
+}, "authorized", false, "default">>;

package/dist/schema/modules/issue/functions/set-issue-parent.js

@@ -0,0 +1,11 @@
+import { method } from '@astrale-os/sdk/schema';
+import { z } from 'zod';
+import { nodeIdValue } from '../../../types/index.js';
+import { ContributeToIssue } from '../policies/contribute-to-issue.js';
+export const setIssueParentMethod = method({
+    description: 'Set or clear this Issue parent inside the same Project.',
+    auth: 'authorized',
+    policy: ({ check, self }) => check(ContributeToIssue, self),
+    input: z.strictObject({ parentId: nodeIdValue.nullable() }),
+    output: z.strictObject({ issueId: nodeIdValue, parentId: nodeIdValue.optional() }),
+});

package/dist/schema/modules/issue/functions/set-issue-tags.d.ts

@@ -0,0 +1,9 @@
+export declare const setIssueTagsMethod: import("@astrale-os/sdk/schema").Method<import("@astrale-os/sdk/schema").CallableProjection<{
+    tagIds: string[];
+}, {
+    readonly mode: 'value';
+    readonly value: {
+        issueId: string;
+        tagIds: string[];
+    };
+}, "authorized", false, "default">>;

package/dist/schema/modules/issue/functions/set-issue-tags.js

@@ -0,0 +1,11 @@
+import { method } from '@astrale-os/sdk/schema';
+import { z } from 'zod';
+import { nodeIdValue } from '../../../types/index.js';
+import { ContributeToIssue } from '../policies/contribute-to-issue.js';
+export const setIssueTagsMethod = method({
+    description: 'Replace this Issue Tag set with an exact Project-local set.',
+    auth: 'authorized',
+    policy: ({ check, self }) => check(ContributeToIssue, self),
+    input: z.strictObject({ tagIds: z.array(nodeIdValue).max(128) }),
+    output: z.strictObject({ issueId: nodeIdValue, tagIds: z.array(nodeIdValue) }),
+});

package/dist/schema/modules/issue/functions/transition-issue.d.ts

@@ -0,0 +1,22 @@
+export declare const transitionIssueMethod: import("@astrale-os/sdk/schema").Method<import("@astrale-os/sdk/schema").CallableProjection<{
+    event: unknown;
+}, {
+    readonly mode: 'value';
+    readonly value: {
+        kind: "transitioned";
+        issue: {
+            id: string;
+            reference: string;
+            title: string;
+            description: string;
+            status: "accepted" | "closed" | "deferred" | "open" | "resolved";
+            priority: number;
+            archived: boolean;
+        };
+    } | {
+        kind: "rejected";
+        code: "STATE_TRANSITION_ILLEGAL";
+        from: "accepted" | "closed" | "deferred" | "open" | "resolved";
+        event: "accept" | "close" | "defer" | "reopen" | "resolve";
+    };
+}, "authorized", false, "default">>;

package/dist/schema/modules/issue/functions/transition-issue.js

@@ -0,0 +1,20 @@
+import { method } from '@astrale-os/sdk/schema';
+import { z } from 'zod';
+import { issueStatus } from '../../../.runtime/states/issue/index.js';
+import { ContributeToIssue } from '../policies/contribute-to-issue.js';
+import { issueValue } from '../types/issue.js';
+export const transitionIssueMethod = method({
+    description: 'Apply one legal Issue status event.',
+    auth: 'authorized',
+    policy: ({ check, self }) => check(ContributeToIssue, self),
+    input: z.strictObject({ event: issueStatus.eventSchema }),
+    output: z.discriminatedUnion('kind', [
+        z.strictObject({ kind: z.literal('transitioned'), issue: issueValue }),
+        z.strictObject({
+            kind: z.literal('rejected'),
+            code: z.literal('STATE_TRANSITION_ILLEGAL'),
+            from: issueStatus.stateSchema,
+            event: issueStatus.eventSchema,
+        }),
+    ]),
+});

package/dist/schema/modules/issue/functions/update-issue.d.ts

@@ -0,0 +1,16 @@
+export declare const updateIssueMethod: import("@astrale-os/sdk/schema").Method<import("@astrale-os/sdk/schema").CallableProjection<{
+    title?: string | undefined;
+    description?: string | undefined;
+    priority?: number | undefined;
+}, {
+    readonly mode: 'value';
+    readonly value: {
+        id: string;
+        reference: string;
+        title: string;
+        description: string;
+        status: "accepted" | "closed" | "deferred" | "open" | "resolved";
+        priority: number;
+        archived: boolean;
+    };
+}, "authorized", false, "default">>;

package/dist/schema/modules/issue/functions/update-issue.js

@@ -0,0 +1,15 @@
+import { method } from '@astrale-os/sdk/schema';
+import { z } from 'zod';
+import { ContributeToIssue } from '../policies/contribute-to-issue.js';
+import { issueValue } from '../types/issue.js';
+export const updateIssueMethod = method({
+    description: 'Update mutable Issue fields.',
+    auth: 'authorized',
+    policy: ({ check, self }) => check(ContributeToIssue, self),
+    input: z.strictObject({
+        title: z.string().min(1).max(200).optional(),
+        description: z.string().max(50_000).optional(),
+        priority: z.number().int().min(0).max(4).optional(),
+    }),
+    output: issueValue,
+});

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

@@ -0,0 +1,4 @@
+export { issueValue } from './types/index.js';
+export { issue_assigned_to, issue_reported_by, issue_subtask_of, Issue, project_contains_issue, } from './classes/index.js';
+export { addIssueCommentMethod, archiveIssueMethod, assignIssueMethod, setIssueParentMethod, setIssueTagsMethod, transitionIssueMethod, updateIssueMethod, } from './functions/index.js';
+export { ContributeToIssue, TraverseIssueAssignee, TraverseIssueParent, TraverseIssueReporter, TraverseProjectIssue, } from './policies/index.js';

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

@@ -0,0 +1,4 @@
+export { issueValue } from './types/index.js';
+export { issue_assigned_to, issue_reported_by, issue_subtask_of, Issue, project_contains_issue, } from './classes/index.js';
+export { addIssueCommentMethod, archiveIssueMethod, assignIssueMethod, setIssueParentMethod, setIssueTagsMethod, transitionIssueMethod, updateIssueMethod, } from './functions/index.js';
+export { ContributeToIssue, TraverseIssueAssignee, TraverseIssueParent, TraverseIssueReporter, TraverseProjectIssue, } from './policies/index.js';

package/dist/schema/{issue/contribute-to-issue-policy.js → modules/issue/policies/contribute-to-issue.js}

@@ -1,6 +1,6 @@
 import { policy } from '@astrale-os/sdk/schema';
-import { Project, project_has_member, project_owned_by } from '../project/index.js';
-import { project_contains_issue } from './relationships.js';
+import { Project, project_has_member, project_owned_by } from '../../project/index.js';
+import { project_contains_issue } from '../classes/project-contains-issue.js';
 export const ContributeToIssue = policy({
     description: 'The caller owns or belongs to the Project containing this Issue.',
     match: ({ allOf, anyOf, edge, exists, object, subject }) => exists(({ node }) => {

package/dist/schema/modules/issue/policies/index.d.ts

@@ -0,0 +1,5 @@
+export { ContributeToIssue } from './contribute-to-issue.js';
+export { TraverseIssueAssignee } from './traverse-issue-assignee.js';
+export { TraverseIssueParent } from './traverse-issue-parent.js';
+export { TraverseIssueReporter } from './traverse-issue-reporter.js';
+export { TraverseProjectIssue } from './traverse-project-issue.js';

package/dist/schema/modules/issue/policies/index.js

@@ -0,0 +1,5 @@
+export { ContributeToIssue } from './contribute-to-issue.js';
+export { TraverseIssueAssignee } from './traverse-issue-assignee.js';
+export { TraverseIssueParent } from './traverse-issue-parent.js';
+export { TraverseIssueReporter } from './traverse-issue-reporter.js';
+export { TraverseProjectIssue } from './traverse-project-issue.js';

package/dist/schema/modules/issue/policies/traverse-issue-assignee.d.ts

@@ -0,0 +1 @@
+export declare const TraverseIssueAssignee: import("@astrale-os/sdk/schema").Policy;

package/dist/schema/modules/issue/policies/traverse-issue-assignee.js

@@ -0,0 +1,14 @@
+import { policy } from '@astrale-os/sdk/schema';
+import { Project, project_has_member, project_owned_by } from '../../project/index.js';
+import { issue_assigned_to } from '../classes/issue-assigned-to.js';
+import { project_contains_issue } from '../classes/project-contains-issue.js';
+export const TraverseIssueAssignee = policy({
+    description: 'Issue assignment relationships are visible only inside the containing Project.',
+    match: ({ allOf, anyOf, edge, exists, source, subject, target }) => anyOf(exists(({ node }) => {
+        const project = node(() => Project);
+        return allOf(edge({ source, class: () => issue_assigned_to, target }), edge({ source: project, class: () => project_contains_issue, target }), edge({ source: subject, class: () => project_owned_by, target: project }));
+    }), exists(({ node }) => {
+        const project = node(() => Project);
+        return allOf(edge({ source, class: () => issue_assigned_to, target }), edge({ source: project, class: () => project_contains_issue, target }), edge({ source: subject, class: () => project_has_member, target: project }));
+    })),
+});

package/dist/schema/modules/issue/policies/traverse-issue-parent.d.ts

@@ -0,0 +1 @@
+export declare const TraverseIssueParent: import("@astrale-os/sdk/schema").Policy;

package/dist/schema/modules/issue/policies/traverse-issue-parent.js

@@ -0,0 +1,14 @@
+import { policy } from '@astrale-os/sdk/schema';
+import { Project, project_has_member, project_owned_by } from '../../project/index.js';
+import { issue_subtask_of } from '../classes/issue-subtask-of.js';
+import { project_contains_issue } from '../classes/project-contains-issue.js';
+export const TraverseIssueParent = policy({
+    description: 'Issue parent relationships are visible only inside the containing Project.',
+    match: ({ allOf, anyOf, edge, exists, source, subject, target }) => anyOf(exists(({ node }) => {
+        const project = node(() => Project);
+        return allOf(edge({ source, class: () => issue_subtask_of, target }), edge({ source: project, class: () => project_contains_issue, target: source }), edge({ source: subject, class: () => project_owned_by, target: project }));
+    }), exists(({ node }) => {
+        const project = node(() => Project);
+        return allOf(edge({ source, class: () => issue_subtask_of, target }), edge({ source: project, class: () => project_contains_issue, target: source }), edge({ source: subject, class: () => project_has_member, target: project }));
+    })),
+});

package/dist/schema/modules/issue/policies/traverse-issue-reporter.d.ts

@@ -0,0 +1 @@
+export declare const TraverseIssueReporter: import("@astrale-os/sdk/schema").Policy;

package/dist/schema/modules/issue/policies/traverse-issue-reporter.js

@@ -0,0 +1,14 @@
+import { policy } from '@astrale-os/sdk/schema';
+import { Project, project_has_member, project_owned_by } from '../../project/index.js';
+import { issue_reported_by } from '../classes/issue-reported-by.js';
+import { project_contains_issue } from '../classes/project-contains-issue.js';
+export const TraverseIssueReporter = policy({
+    description: 'Issue reporter relationships are visible only inside the containing Project.',
+    match: ({ allOf, anyOf, edge, exists, source, subject, target }) => anyOf(exists(({ node }) => {
+        const project = node(() => Project);
+        return allOf(edge({ source, class: () => issue_reported_by, target }), edge({ source: project, class: () => project_contains_issue, target }), edge({ source: subject, class: () => project_owned_by, target: project }));
+    }), exists(({ node }) => {
+        const project = node(() => Project);
+        return allOf(edge({ source, class: () => issue_reported_by, target }), edge({ source: project, class: () => project_contains_issue, target }), edge({ source: subject, class: () => project_has_member, target: project }));
+    })),
+});

package/dist/schema/modules/issue/policies/traverse-project-issue.d.ts

@@ -0,0 +1 @@
+export declare const TraverseProjectIssue: import("@astrale-os/sdk/schema").Policy;

package/dist/schema/modules/issue/policies/traverse-project-issue.js

@@ -0,0 +1,7 @@
+import { policy } from '@astrale-os/sdk/schema';
+import { project_has_member, project_owned_by } from '../../project/index.js';
+import { project_contains_issue } from '../classes/project-contains-issue.js';
+export const TraverseProjectIssue = policy({
+    description: 'Project Issue containment is visible only to that Project owner and members.',
+    match: ({ allOf, anyOf, edge, source, subject, target }) => anyOf(allOf(edge({ source, class: () => project_contains_issue, target }), edge({ source: subject, class: () => project_owned_by, target: source })), allOf(edge({ source, class: () => project_contains_issue, target }), edge({ source: subject, class: () => project_has_member, target: source }))),
+});

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

@@ -0,0 +1 @@
+export { issueValue } from './issue.js';

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

@@ -0,0 +1 @@
+export { issueValue } from './issue.js';

package/dist/schema/modules/issue/types/issue.d.ts

@@ -0,0 +1,10 @@
+import { z } from 'zod';
+export declare const issueValue: z.ZodObject<{
+    id: z.ZodString;
+    reference: z.ZodString;
+    title: z.ZodString;
+    description: z.ZodString;
+    status: z.ZodType<"accepted" | "closed" | "deferred" | "open" | "resolved", unknown, z.core.$ZodTypeInternals<"accepted" | "closed" | "deferred" | "open" | "resolved", unknown>>;
+    priority: z.ZodNumber;
+    archived: z.ZodBoolean;
+}, z.core.$strict>;

package/dist/schema/modules/issue/types/issue.js

@@ -0,0 +1,12 @@
+import { z } from 'zod';
+import { nodeIdValue } from '../../../types/index.js';
+import { issueStatus } from '../../../.runtime/states/issue/index.js';
+export const issueValue = z.strictObject({
+    id: nodeIdValue,
+    reference: z.string().min(1).max(32),
+    title: z.string().min(1).max(200),
+    description: z.string().max(50_000),
+    status: issueStatus.stateSchema,
+    priority: z.number().int().min(0).max(4),
+    archived: z.boolean(),
+});

package/dist/schema/modules/project/classes/index.d.ts

@@ -0,0 +1,3 @@
+export { project_has_member } from './project-has-member.js';
+export { project_owned_by } from './project-owned-by.js';
+export { Project } from './project.js';

package/dist/schema/modules/project/classes/index.js

@@ -0,0 +1,3 @@
+export { project_has_member } from './project-has-member.js';
+export { project_owned_by } from './project-owned-by.js';
+export { Project } from './project.js';

package/dist/schema/{project/relationships.d.ts → modules/project/classes/project-has-member.d.ts}

@@ -1,19 +1,3 @@
-export declare const project_owned_by: import("@astrale-os/sdk/schema").DirectedEdgeClass<{
-    readonly depth: 0;
-    readonly abstract: false;
-    readonly extends: readonly [];
-    readonly properties: never;
-    readonly source: {
-        readonly as: "owner";
-        readonly outgoing: "0..*";
-    };
-    readonly target: {
-        readonly as: "project";
-        readonly incoming: "1";
-    };
-    readonly constraints: Record<never, never>;
-    readonly effectiveProperties: never;
-}>;
 export declare const project_has_member: import("@astrale-os/sdk/schema").DirectedEdgeClass<{
     readonly depth: 0;
     readonly abstract: false;

package/dist/schema/modules/project/classes/project-has-member.js

@@ -0,0 +1,9 @@
+import { K, edgeClass } from '@astrale-os/sdk/schema';
+import { TraverseProjectMember } from '../policies/traverse-project-member.js';
+import { Project } from './project.js';
+export const project_has_member = edgeClass.directed({
+    description: 'An Identity admitted to collaborate in one Project.',
+    source: { as: 'member', accepts: [K.classes.Identity], outgoing: '0..*' },
+    target: { as: 'project', accepts: [() => Project], incoming: '0..*' },
+    policies: { traverse: () => TraverseProjectMember },
+});

package/dist/schema/modules/project/classes/project-owned-by.d.ts

@@ -0,0 +1,16 @@
+export declare const project_owned_by: import("@astrale-os/sdk/schema").DirectedEdgeClass<{
+    readonly depth: 0;
+    readonly abstract: false;
+    readonly extends: readonly [];
+    readonly properties: never;
+    readonly source: {
+        readonly as: "owner";
+        readonly outgoing: "0..*";
+    };
+    readonly target: {
+        readonly as: "project";
+        readonly incoming: "1";
+    };
+    readonly constraints: Record<never, never>;
+    readonly effectiveProperties: never;
+}>;

package/dist/schema/modules/project/classes/project-owned-by.js

@@ -0,0 +1,9 @@
+import { K, edgeClass } from '@astrale-os/sdk/schema';
+import { TraverseProjectOwner } from '../policies/traverse-project-owner.js';
+import { Project } from './project.js';
+export const project_owned_by = edgeClass.directed({
+    description: 'The exact Identity that owns and administers one Project.',
+    source: { as: 'owner', accepts: [K.classes.Identity], outgoing: '0..*' },
+    target: { as: 'project', accepts: [() => Project], incoming: '1' },
+    policies: { traverse: () => TraverseProjectOwner },
+});

package/dist/schema/{project/class.d.ts → modules/project/classes/project.d.ts}

@@ -72,6 +72,31 @@ export declare const Project: import("@astrale-os/sdk/schema").NodeClass<{
                 archived: boolean;
             };
         }, "authenticated", true, "default">>;
+        readonly list: import("@astrale-os/sdk/schema").Method<import("@astrale-os/sdk/schema").CallableProjection<Record<string, never>, {
+            readonly mode: 'value';
+            readonly value: {
+                projects: {
+                    id: string;
+                    key: string;
+                    name: string;
+                    description: string;
+                    archived: boolean;
+                    issues: {
+                        id: string;
+                        reference: string;
+                        title: string;
+                        description: string;
+                        status: "accepted" | "closed" | "deferred" | "open" | "resolved";
+                        priority: number;
+                        archived: boolean;
+                        comments: {
+                            id: string;
+                            body: string;
+                        }[];
+                    }[];
+                }[];
+            };
+        }, "authenticated", true, "default">>;
         readonly update: import("@astrale-os/sdk/schema").Method<import("@astrale-os/sdk/schema").CallableProjection<{
             name?: string | undefined;
             description?: string | undefined;
@@ -161,6 +186,15 @@ export declare const Project: import("@astrale-os/sdk/schema").NodeClass<{
             archived: true;
         };
     }, "authorized", false, "default">>, "archive", "self"> | import("@astrale-os/sdk/schema").AuthoredMethodProjection<import("@astrale-os/sdk/schema").Method<import("@astrale-os/sdk/schema").CallableProjection<{
+        memberId: string;
+    }, {
+        readonly mode: 'value';
+        readonly value: {
+            projectId: string;
+            memberId: string;
+            changed: boolean;
+        };
+    }, "authorized", false, "default">>, "addMember", "self"> | import("@astrale-os/sdk/schema").AuthoredMethodProjection<import("@astrale-os/sdk/schema").Method<import("@astrale-os/sdk/schema").CallableProjection<{
         name?: string | undefined;
         description?: string | undefined;
     }, {
@@ -181,15 +215,6 @@ export declare const Project: import("@astrale-os/sdk/schema").NodeClass<{
             memberId: string;
             changed: boolean;
         };
-    }, "authorized", false, "default">>, "addMember", "self"> | import("@astrale-os/sdk/schema").AuthoredMethodProjection<import("@astrale-os/sdk/schema").Method<import("@astrale-os/sdk/schema").CallableProjection<{
-        memberId: string;
-    }, {
-        readonly mode: 'value';
-        readonly value: {
-            projectId: string;
-            memberId: string;
-            changed: boolean;
-        };
     }, "authorized", false, "default">>, "removeMember", "self"> | import("@astrale-os/sdk/schema").AuthoredMethodProjection<import("@astrale-os/sdk/schema").Method<import("@astrale-os/sdk/schema").CallableProjection<{
         title: string;
         description?: string | undefined;
@@ -217,7 +242,31 @@ export declare const Project: import("@astrale-os/sdk/schema").NodeClass<{
             color?: string | undefined;
         };
     }, "authorized", false, "default">>, "createTag", "self">;
-    readonly effectiveStaticMethods: import("@astrale-os/sdk/schema").AuthoredMethodProjection<import("@astrale-os/sdk/schema").Method<import("@astrale-os/sdk/schema").CallableProjection<{
+    readonly effectiveStaticMethods: import("@astrale-os/sdk/schema").AuthoredMethodProjection<import("@astrale-os/sdk/schema").Method<import("@astrale-os/sdk/schema").CallableProjection<Record<string, never>, {
+        readonly mode: 'value';
+        readonly value: {
+            projects: {
+                id: string;
+                key: string;
+                name: string;
+                description: string;
+                archived: boolean;
+                issues: {
+                    id: string;
+                    reference: string;
+                    title: string;
+                    description: string;
+                    status: "accepted" | "closed" | "deferred" | "open" | "resolved";
+                    priority: number;
+                    archived: boolean;
+                    comments: {
+                        id: string;
+                        body: string;
+                    }[];
+                }[];
+            }[];
+        };
+    }, "authenticated", true, "default">>, "list", "self"> | import("@astrale-os/sdk/schema").AuthoredMethodProjection<import("@astrale-os/sdk/schema").Method<import("@astrale-os/sdk/schema").CallableProjection<{
         key: string;
         name: string;
         description?: string | undefined;
@@ -231,4 +280,4 @@ export declare const Project: import("@astrale-os/sdk/schema").NodeClass<{
             archived: boolean;
         };
     }, "authenticated", true, "default">>, "create", "self">;
-}>;
+}> & import("@astrale-os/sdk/schema").StateClass<Readonly<Omit<Readonly<Record<never, never>>, never> & {}>>;

package/dist/schema/modules/project/classes/project.js

@@ -0,0 +1,35 @@
+import { K, nodeClass, property } from '@astrale-os/sdk/schema';
+import { z } from 'zod';
+import { nodeIdValue } from '../../../types/index.js';
+import { addProjectMemberMethod } from '../functions/add-project-member.js';
+import { archiveProjectMethod } from '../functions/archive-project.js';
+import { createProjectIssueMethod } from '../functions/create-project-issue.js';
+import { createProjectTagMethod } from '../functions/create-project-tag.js';
+import { createProjectMethod } from '../functions/create-project.js';
+import { listProjectsMethod } from '../functions/list-projects.js';
+import { removeProjectMemberMethod } from '../functions/remove-project-member.js';
+import { updateProjectMethod } from '../functions/update-project.js';
+import { ContributeToProject } from '../policies/contribute-to-project.js';
+export const Project = nodeClass({
+    description: 'A collaborative namespace for numbered Issues, Tags, and membership.',
+    icon: 'folder-kanban',
+    extends: [K.classes.Named, K.classes.Descriptable, K.classes.Timestamped],
+    properties: {
+        key: z.string().min(2).max(10),
+        ownerId: property(nodeIdValue, {}),
+        memberIds: property(z.array(nodeIdValue).max(256), {}),
+        nextIssueNumber: property(z.number().int().min(1), {}),
+        archived: z.boolean(),
+    },
+    methods: {
+        create: createProjectMethod,
+        list: listProjectsMethod,
+        update: updateProjectMethod,
+        addMember: addProjectMemberMethod,
+        removeMember: removeProjectMemberMethod,
+        createIssue: createProjectIssueMethod,
+        createTag: createProjectTagMethod,
+        archive: archiveProjectMethod,
+    },
+    policies: { read: () => ContributeToProject },
+});

package/dist/schema/modules/project/functions/add-project-member.d.ts

@@ -0,0 +1,10 @@
+export declare const addProjectMemberMethod: import("@astrale-os/sdk/schema").Method<import("@astrale-os/sdk/schema").CallableProjection<{
+    memberId: string;
+}, {
+    readonly mode: 'value';
+    readonly value: {
+        projectId: string;
+        memberId: string;
+        changed: boolean;
+    };
+}, "authorized", false, "default">>;

package/dist/schema/modules/project/functions/add-project-member.js

@@ -0,0 +1,12 @@
+import { method } from '@astrale-os/sdk/schema';
+import { z } from 'zod';
+import { nodeIdValue } from '../../../types/index.js';
+import { ManageProject } from '../policies/manage-project.js';
+import { membershipChangeValue } from '../types/membership-change.js';
+export const addProjectMemberMethod = method({
+    description: 'Add one Identity as a Project member.',
+    auth: 'authorized',
+    policy: ({ check, self }) => check(ManageProject, self),
+    input: z.strictObject({ memberId: nodeIdValue }),
+    output: membershipChangeValue,
+});

package/dist/schema/modules/project/functions/archive-project.d.ts

@@ -0,0 +1,7 @@
+export declare const archiveProjectMethod: import("@astrale-os/sdk/schema").Method<import("@astrale-os/sdk/schema").CallableProjection<Record<string, never>, {
+    readonly mode: 'value';
+    readonly value: {
+        projectId: string;
+        archived: true;
+    };
+}, "authorized", false, "default">>;

package/dist/schema/modules/project/functions/archive-project.js

@@ -0,0 +1,11 @@
+import { method } from '@astrale-os/sdk/schema';
+import { z } from 'zod';
+import { nodeIdValue } from '../../../types/index.js';
+import { ManageProject } from '../policies/manage-project.js';
+export const archiveProjectMethod = method({
+    description: 'Archive this Project without deleting its aggregate.',
+    auth: 'authorized',
+    policy: ({ check, self }) => check(ManageProject, self),
+    input: z.strictObject({}),
+    output: z.strictObject({ projectId: nodeIdValue, archived: z.literal(true) }),
+});