@astrale-domains/issues 0.1.2 → 0.1.4

package/dist/schema/modules/issue/policies/contribute-to-issue.js

@@ -0,0 +1,10 @@
+import { policy } from '@astrale-os/sdk/schema';
+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 }) => {
+        const project = node(() => Project);
+        return allOf(anyOf(edge({ source: subject, class: () => project_owned_by, target: project }), edge({ source: subject, class: () => project_has_member, target: project })), edge({ source: project, class: () => project_contains_issue, target: object }));
+    }),
+});

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/modules/project/classes/project-has-member.d.ts

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

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/{tracker/relationships.d.ts → modules/project/classes/project-owned-by.d.ts}

@@ -1,15 +1,15 @@
-export declare const tracker_owned_by: import("@astrale-os/sdk/schema").DirectedEdgeClass<{
+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: "tracker";
-        readonly outgoing: "1";
+        readonly as: "owner";
+        readonly outgoing: "0..*";
     };
     readonly target: {
-        readonly as: "owner";
-        readonly incoming: "0..*";
+        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/modules/project/classes/project.d.ts

@@ -0,0 +1,283 @@
+export declare const Project: import("@astrale-os/sdk/schema").NodeClass<{
+    readonly depth: 1;
+    readonly abstract: false;
+    readonly extends: readonly [import("@astrale-os/sdk/schema").ClassProjection<"node", import("@astrale-os/sdk/schema").NodeClassDefinition & {
+        readonly ref: import("@astrale-os/sdk/schema").ClassRef<"Named"> & {
+            readonly origin: "kernel.astrale.ai";
+        };
+        readonly kind: 'node';
+        readonly abstract: true;
+    }, import("@astrale-os/sdk/schema").ClassRef & import("@astrale-os/sdk/schema").ClassRef<"Named"> & {
+        readonly origin: "kernel.astrale.ai";
+    }, "kernel.astrale.ai:class.Named", readonly [import("@astrale-os/sdk/schema").ClassProjection<"node", import("@astrale-os/sdk/schema").NodeClassDefinition & {
+        readonly ref: import("@astrale-os/sdk/schema").ClassRef<"Node"> & {
+            readonly origin: "kernel.astrale.ai";
+        };
+        readonly kind: 'node';
+        readonly abstract: true;
+    }, import("@astrale-os/sdk/schema").ClassRef & import("@astrale-os/sdk/schema").ClassRef<"Node"> & {
+        readonly origin: "kernel.astrale.ai";
+    }, "kernel.astrale.ai:class.Node", readonly import("@astrale-os/sdk/schema").AnyResolvedClass[], never, never, never, never, never, never>, ...never[]], import("@astrale-os/sdk/schema").PropertyProjection<string | number | boolean | import("@astrale-os/sdk/schema").Array | import("@astrale-os/sdk/schema").Object | null, true, "name", "kernel.astrale.ai:class.Named.property.name">, never, never, import("@astrale-os/sdk/schema").PropertyProjection<string | number | boolean | import("@astrale-os/sdk/schema").Array | import("@astrale-os/sdk/schema").Object | null, true, "name", "kernel.astrale.ai:class.Named.property.name">, never, never>, import("@astrale-os/sdk/schema").ClassProjection<"node", import("@astrale-os/sdk/schema").NodeClassDefinition & {
+        readonly ref: import("@astrale-os/sdk/schema").ClassRef<"Descriptable"> & {
+            readonly origin: "kernel.astrale.ai";
+        };
+        readonly kind: 'node';
+        readonly abstract: true;
+    }, import("@astrale-os/sdk/schema").ClassRef & import("@astrale-os/sdk/schema").ClassRef<"Descriptable"> & {
+        readonly origin: "kernel.astrale.ai";
+    }, "kernel.astrale.ai:class.Descriptable", readonly [import("@astrale-os/sdk/schema").ClassProjection<"node", import("@astrale-os/sdk/schema").NodeClassDefinition & {
+        readonly ref: import("@astrale-os/sdk/schema").ClassRef<"Node"> & {
+            readonly origin: "kernel.astrale.ai";
+        };
+        readonly kind: 'node';
+        readonly abstract: true;
+    }, import("@astrale-os/sdk/schema").ClassRef & import("@astrale-os/sdk/schema").ClassRef<"Node"> & {
+        readonly origin: "kernel.astrale.ai";
+    }, "kernel.astrale.ai:class.Node", readonly import("@astrale-os/sdk/schema").AnyResolvedClass[], never, never, never, never, never, never>, ...never[]], import("@astrale-os/sdk/schema").PropertyProjection<string | number | boolean | import("@astrale-os/sdk/schema").Array | import("@astrale-os/sdk/schema").Object | null, false, "description", "kernel.astrale.ai:class.Descriptable.property.description">, never, never, import("@astrale-os/sdk/schema").PropertyProjection<string | number | boolean | import("@astrale-os/sdk/schema").Array | import("@astrale-os/sdk/schema").Object | null, false, "description", "kernel.astrale.ai:class.Descriptable.property.description">, never, never>, import("@astrale-os/sdk/schema").ClassProjection<"node", import("@astrale-os/sdk/schema").NodeClassDefinition & {
+        readonly ref: import("@astrale-os/sdk/schema").ClassRef<"Timestamped"> & {
+            readonly origin: "kernel.astrale.ai";
+        };
+        readonly kind: 'node';
+        readonly abstract: true;
+    }, import("@astrale-os/sdk/schema").ClassRef & import("@astrale-os/sdk/schema").ClassRef<"Timestamped"> & {
+        readonly origin: "kernel.astrale.ai";
+    }, "kernel.astrale.ai:class.Timestamped", readonly [import("@astrale-os/sdk/schema").ClassProjection<"node", import("@astrale-os/sdk/schema").NodeClassDefinition & {
+        readonly ref: import("@astrale-os/sdk/schema").ClassRef<"Node"> & {
+            readonly origin: "kernel.astrale.ai";
+        };
+        readonly kind: 'node';
+        readonly abstract: true;
+    }, import("@astrale-os/sdk/schema").ClassRef & import("@astrale-os/sdk/schema").ClassRef<"Node"> & {
+        readonly origin: "kernel.astrale.ai";
+    }, "kernel.astrale.ai:class.Node", readonly import("@astrale-os/sdk/schema").AnyResolvedClass[], never, never, never, never, never, never>, ...never[]], import("@astrale-os/sdk/schema").PropertyProjection<string | number | boolean | import("@astrale-os/sdk/schema").Array | import("@astrale-os/sdk/schema").Object | null, true, "createdAt", "kernel.astrale.ai:class.Timestamped.property.createdAt"> | import("@astrale-os/sdk/schema").PropertyProjection<string | number | boolean | import("@astrale-os/sdk/schema").Array | import("@astrale-os/sdk/schema").Object | null, true, "updatedAt", "kernel.astrale.ai:class.Timestamped.property.updatedAt">, never, never, import("@astrale-os/sdk/schema").PropertyProjection<string | number | boolean | import("@astrale-os/sdk/schema").Array | import("@astrale-os/sdk/schema").Object | null, true, "createdAt", "kernel.astrale.ai:class.Timestamped.property.createdAt"> | import("@astrale-os/sdk/schema").PropertyProjection<string | number | boolean | import("@astrale-os/sdk/schema").Array | import("@astrale-os/sdk/schema").Object | null, true, "updatedAt", "kernel.astrale.ai:class.Timestamped.property.updatedAt">, never, never>];
+    readonly properties: {
+        readonly key: import("@astrale-os/sdk/schema").AuthoredPropertyProjection<string, string, true, "key", "self">;
+        readonly ownerId: import("@astrale-os/sdk/schema").AuthoredPropertyProjection<string, string, true, "ownerId", "self">;
+        readonly memberIds: import("@astrale-os/sdk/schema").AuthoredPropertyProjection<string[], string[], true, "memberIds", "self">;
+        readonly nextIssueNumber: import("@astrale-os/sdk/schema").AuthoredPropertyProjection<number, number, true, "nextIssueNumber", "self">;
+        readonly archived: import("@astrale-os/sdk/schema").AuthoredPropertyProjection<boolean, boolean, true, "archived", "self">;
+    };
+    readonly methods: {
+        readonly create: import("@astrale-os/sdk/schema").Method<import("@astrale-os/sdk/schema").CallableProjection<{
+            key: string;
+            name: string;
+            description?: string | undefined;
+        }, {
+            readonly mode: 'value';
+            readonly value: {
+                id: string;
+                key: string;
+                name: string;
+                description: string;
+                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;
+        }, {
+            readonly mode: 'value';
+            readonly value: {
+                id: string;
+                key: string;
+                name: string;
+                description: string;
+                archived: boolean;
+            };
+        }, "authorized", false, "default">>;
+        readonly addMember: 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">>;
+        readonly removeMember: 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">>;
+        readonly createIssue: import("@astrale-os/sdk/schema").Method<import("@astrale-os/sdk/schema").CallableProjection<{
+            title: string;
+            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">>;
+        readonly createTag: import("@astrale-os/sdk/schema").Method<import("@astrale-os/sdk/schema").CallableProjection<{
+            name: string;
+            color?: string | undefined;
+        }, {
+            readonly mode: 'value';
+            readonly value: {
+                id: string;
+                name: string;
+                slug: string;
+                color?: string | undefined;
+            };
+        }, "authorized", false, "default">>;
+        readonly archive: 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">>;
+    };
+    readonly effectiveProperties: (import("@astrale-os/sdk/schema").AuthoredPropertyProjection<boolean, boolean, true, "archived", "self"> | import("@astrale-os/sdk/schema").AuthoredPropertyProjection<string, string, true, "key", "self"> | import("@astrale-os/sdk/schema").AuthoredPropertyProjection<string[], string[], true, "memberIds", "self"> | import("@astrale-os/sdk/schema").AuthoredPropertyProjection<number, number, true, "nextIssueNumber", "self"> | import("@astrale-os/sdk/schema").AuthoredPropertyProjection<string, string, true, "ownerId", "self">) | (import("@astrale-os/sdk/schema").ResolvedProperty<import("@astrale-os/sdk/schema").Value, false> & {
+        readonly name: "description";
+        readonly key: "kernel.astrale.ai:class.Descriptable.property.description";
+    }) | (import("@astrale-os/sdk/schema").ResolvedProperty<import("@astrale-os/sdk/schema").Value, true> & {
+        readonly name: "createdAt";
+        readonly key: "kernel.astrale.ai:class.Timestamped.property.createdAt";
+    }) | (import("@astrale-os/sdk/schema").ResolvedProperty<import("@astrale-os/sdk/schema").Value, true> & {
+        readonly name: "name";
+        readonly key: "kernel.astrale.ai:class.Named.property.name";
+    }) | (import("@astrale-os/sdk/schema").ResolvedProperty<import("@astrale-os/sdk/schema").Value, true> & {
+        readonly name: "updatedAt";
+        readonly key: "kernel.astrale.ai:class.Timestamped.property.updatedAt";
+    });
+    readonly effectiveInstanceMethods: 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: {
+            projectId: string;
+            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;
+    }, {
+        readonly mode: 'value';
+        readonly value: {
+            id: string;
+            key: string;
+            name: string;
+            description: string;
+            archived: boolean;
+        };
+    }, "authorized", false, "default">>, "update", "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;
+        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">>, "createIssue", "self"> | import("@astrale-os/sdk/schema").AuthoredMethodProjection<import("@astrale-os/sdk/schema").Method<import("@astrale-os/sdk/schema").CallableProjection<{
+        name: string;
+        color?: string | undefined;
+    }, {
+        readonly mode: 'value';
+        readonly value: {
+            id: string;
+            name: string;
+            slug: string;
+            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<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;
+    }, {
+        readonly mode: 'value';
+        readonly value: {
+            id: string;
+            key: string;
+            name: string;
+            description: string;
+            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) }),
+});

package/dist/schema/modules/project/functions/create-project-issue.d.ts

@@ -0,0 +1,16 @@
+export declare const createProjectIssueMethod: import("@astrale-os/sdk/schema").Method<import("@astrale-os/sdk/schema").CallableProjection<{
+    title: string;
+    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/project/functions/create-project-issue.js

@@ -0,0 +1,15 @@
+import { method } from '@astrale-os/sdk/schema';
+import { z } from 'zod';
+import { issueValue } from '../../issue/index.js';
+import { ContributeToProject } from '../policies/contribute-to-project.js';
+export const createProjectIssueMethod = method({
+    description: 'Create one atomically numbered Issue in this Project.',
+    auth: 'authorized',
+    policy: ({ check, self }) => check(ContributeToProject, self),
+    input: z.strictObject({
+        title: z.string().min(1).max(200),
+        description: z.string().max(50_000).optional(),
+        priority: z.number().int().min(0).max(4).optional(),
+    }),
+    output: issueValue,
+});

package/dist/schema/modules/project/functions/create-project-tag.d.ts

@@ -0,0 +1,12 @@
+export declare const createProjectTagMethod: import("@astrale-os/sdk/schema").Method<import("@astrale-os/sdk/schema").CallableProjection<{
+    name: string;
+    color?: string | undefined;
+}, {
+    readonly mode: 'value';
+    readonly value: {
+        id: string;
+        name: string;
+        slug: string;
+        color?: string | undefined;
+    };
+}, "authorized", false, "default">>;