@astrale-domains/issues 0.3.2 → 0.3.4

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

@@ -5,9 +5,9 @@ export declare const Project: import("@astrale-os/sdk/schema").AuthoredNodeClass
     readonly extends: readonly [import("@astrale-os/sdk/schema").KernelClass<"Named">, import("@astrale-os/sdk/schema").KernelClass<"Descriptable">, import("@astrale-os/sdk/schema").KernelClass<"Timestamped">];
     readonly properties: {
         key: z.ZodString;
-        ownerId: import("@astrale-os/sdk/schema").Property<z.ZodString, {}, never>;
-        memberIds: import("@astrale-os/sdk/schema").Property<z.ZodArray<z.ZodString>, {}, never>;
-        nextIssueNumber: import("@astrale-os/sdk/schema").Property<z.ZodNumber, {}, never>;
+        ownerId: import("@astrale-os/sdk/schema").AuthoredProperty<z.ZodString, {}>;
+        memberIds: import("@astrale-os/sdk/schema").AuthoredProperty<z.ZodArray<z.ZodString>, {}>;
+        nextIssueNumber: import("@astrale-os/sdk/schema").AuthoredProperty<z.ZodNumber, {}>;
         archived: z.ZodBoolean;
     };
     readonly methods: {
@@ -99,6 +99,106 @@ export declare const Project: import("@astrale-os/sdk/schema").AuthoredNodeClass
                 archived: boolean;
             };
         }, "authorized", false, false>>;
+        receiveReport: import("@astrale-os/sdk/schema").Method<import("@astrale-os/sdk/schema").CallableProjection<{
+            title: string;
+            body: string;
+            context?: {
+                observedAt: string;
+                cli: {
+                    version: string;
+                    platform: string;
+                    arch: string;
+                };
+                runtime: {
+                    node: string;
+                    bun?: string | undefined;
+                };
+                project?: {
+                    name: string;
+                    version?: string | undefined;
+                    packages: {
+                        name: string;
+                        declared?: string | undefined;
+                        version?: string | undefined;
+                        source: "installed" | "local" | "unresolved";
+                        commit?: string | undefined;
+                        dirty?: boolean | undefined;
+                    }[];
+                } | undefined;
+                instance?: {
+                    name: string;
+                    issuer?: string | undefined;
+                    url?: string | undefined;
+                } | undefined;
+            } | undefined;
+            requestId: string;
+            reporterId: string;
+        }, {
+            readonly mode: 'value';
+            readonly value: {
+                id: string;
+                reference: string;
+            };
+        }, "authorized", false, false>>;
+        listReports: import("@astrale-os/sdk/schema").Method<import("@astrale-os/sdk/schema").CallableProjection<{
+            pending?: boolean | undefined;
+            cursor?: string | undefined;
+        }, {
+            readonly mode: 'value';
+            readonly value: {
+                reports: {
+                    id: string;
+                    reference: string;
+                    reporterId: string;
+                    content: {
+                        title: string;
+                        body: string;
+                        context?: {
+                            observedAt: string;
+                            cli: {
+                                version: string;
+                                platform: string;
+                                arch: string;
+                            };
+                            runtime: {
+                                node: string;
+                                bun?: string | undefined;
+                            };
+                            project?: {
+                                name: string;
+                                version?: string | undefined;
+                                packages: {
+                                    name: string;
+                                    declared?: string | undefined;
+                                    version?: string | undefined;
+                                    source: "installed" | "local" | "unresolved";
+                                    commit?: string | undefined;
+                                    dirty?: boolean | undefined;
+                                }[];
+                            } | undefined;
+                            instance?: {
+                                name: string;
+                                issuer?: string | undefined;
+                                url?: string | undefined;
+                            } | undefined;
+                        } | undefined;
+                    };
+                    pending: boolean;
+                    receivedAt: string;
+                }[];
+                cursor?: string | undefined;
+            };
+        }, "authorized", false, false>>;
+        completeReport: import("@astrale-os/sdk/schema").Method<import("@astrale-os/sdk/schema").CallableProjection<{
+            issueId: string;
+            duplicateCandidateId?: string | undefined;
+        }, {
+            readonly mode: 'value';
+            readonly value: {
+                issueId: string;
+                changed: boolean;
+            };
+        }, "authorized", false, false>>;
         createTag: import("@astrale-os/sdk/schema").Method<import("@astrale-os/sdk/schema").CallableProjection<{
             name: string;
             color?: string | undefined;

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

@@ -4,10 +4,13 @@ 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 { completeProjectReportMethod } from '../functions/complete-project-report.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 { listProjectReportsMethod } from '../functions/list-project-reports.js';
 import { listProjectsMethod } from '../functions/list-projects.js';
+import { receiveProjectReportMethod } from '../functions/receive-project-report.js';
 import { removeProjectMemberMethod } from '../functions/remove-project-member.js';
 import { updateProjectMethod } from '../functions/update-project.js';
 import { ContributeToProject } from '../policies/contribute-to-project.js';
@@ -29,6 +32,9 @@ export const Project = nodeClass({
         addMember: addProjectMemberMethod,
         removeMember: removeProjectMemberMethod,
         createIssue: createProjectIssueMethod,
+        receiveReport: receiveProjectReportMethod,
+        listReports: listProjectReportsMethod,
+        completeReport: completeProjectReportMethod,
         createTag: createProjectTagMethod,
         archive: archiveProjectMethod,
     },

package/dist/schema/modules/project/functions/complete-project-report.d.ts

@@ -0,0 +1,10 @@
+export declare const completeProjectReportMethod: import("@astrale-os/sdk/schema").Method<import("@astrale-os/sdk/schema").CallableProjection<{
+    issueId: string;
+    duplicateCandidateId?: string | undefined;
+}, {
+    readonly mode: 'value';
+    readonly value: {
+        issueId: string;
+        changed: boolean;
+    };
+}, "authorized", false, false>>;

package/dist/schema/modules/project/functions/complete-project-report.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 completeProjectReportMethod = method({
+    description: 'Confirm report processing once, optionally adding one duplicate candidate without editing original evidence or human triage.',
+    auth: 'authorized',
+    policy: ({ check, self }) => check(ManageProject, self),
+    input: z.strictObject({ issueId: nodeIdValue, duplicateCandidateId: nodeIdValue.optional() }),
+    output: z.strictObject({ issueId: nodeIdValue, changed: z.boolean() }),
+});

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

@@ -6,3 +6,6 @@ export { createProjectMethod } from './create-project.js';
 export { listProjectsMethod } from './list-projects.js';
 export { removeProjectMemberMethod } from './remove-project-member.js';
 export { updateProjectMethod } from './update-project.js';
+export { receiveProjectReportMethod } from './receive-project-report.js';
+export { listProjectReportsMethod } from './list-project-reports.js';
+export { completeProjectReportMethod } from './complete-project-report.js';

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

@@ -6,3 +6,6 @@ export { createProjectMethod } from './create-project.js';
 export { listProjectsMethod } from './list-projects.js';
 export { removeProjectMemberMethod } from './remove-project-member.js';
 export { updateProjectMethod } from './update-project.js';
+export { receiveProjectReportMethod } from './receive-project-report.js';
+export { listProjectReportsMethod } from './list-project-reports.js';
+export { completeProjectReportMethod } from './complete-project-report.js';

package/dist/schema/modules/project/functions/list-project-reports.d.ts

@@ -0,0 +1,49 @@
+export declare const listProjectReportsMethod: import("@astrale-os/sdk/schema").Method<import("@astrale-os/sdk/schema").CallableProjection<{
+    pending?: boolean | undefined;
+    cursor?: string | undefined;
+}, {
+    readonly mode: 'value';
+    readonly value: {
+        reports: {
+            id: string;
+            reference: string;
+            reporterId: string;
+            content: {
+                title: string;
+                body: string;
+                context?: {
+                    observedAt: string;
+                    cli: {
+                        version: string;
+                        platform: string;
+                        arch: string;
+                    };
+                    runtime: {
+                        node: string;
+                        bun?: string | undefined;
+                    };
+                    project?: {
+                        name: string;
+                        version?: string | undefined;
+                        packages: {
+                            name: string;
+                            declared?: string | undefined;
+                            version?: string | undefined;
+                            source: "installed" | "local" | "unresolved";
+                            commit?: string | undefined;
+                            dirty?: boolean | undefined;
+                        }[];
+                    } | undefined;
+                    instance?: {
+                        name: string;
+                        issuer?: string | undefined;
+                        url?: string | undefined;
+                    } | undefined;
+                } | undefined;
+            };
+            pending: boolean;
+            receivedAt: string;
+        }[];
+        cursor?: string | undefined;
+    };
+}, "authorized", false, false>>;

package/dist/schema/modules/project/functions/list-project-reports.js

@@ -0,0 +1,14 @@
+import { method } from '@astrale-os/sdk/schema';
+import { z } from 'zod';
+import { reportPageValue } from '../../issue/index.js';
+import { ManageProject } from '../policies/manage-project.js';
+export const listProjectReportsMethod = method({
+    description: 'Read one bounded page of original reports for this Project owner; resume the returned cursor with the same pending filter.',
+    auth: 'authorized',
+    policy: ({ check, self }) => check(ManageProject, self),
+    input: z.strictObject({
+        pending: z.boolean().optional(),
+        cursor: z.string().max(16_384).optional(),
+    }),
+    output: reportPageValue,
+});

package/dist/schema/modules/project/functions/receive-project-report.d.ts

@@ -0,0 +1,41 @@
+export declare const receiveProjectReportMethod: import("@astrale-os/sdk/schema").Method<import("@astrale-os/sdk/schema").CallableProjection<{
+    title: string;
+    body: string;
+    context?: {
+        observedAt: string;
+        cli: {
+            version: string;
+            platform: string;
+            arch: string;
+        };
+        runtime: {
+            node: string;
+            bun?: string | undefined;
+        };
+        project?: {
+            name: string;
+            version?: string | undefined;
+            packages: {
+                name: string;
+                declared?: string | undefined;
+                version?: string | undefined;
+                source: "installed" | "local" | "unresolved";
+                commit?: string | undefined;
+                dirty?: boolean | undefined;
+            }[];
+        } | undefined;
+        instance?: {
+            name: string;
+            issuer?: string | undefined;
+            url?: string | undefined;
+        } | undefined;
+    } | undefined;
+    requestId: string;
+    reporterId: string;
+}, {
+    readonly mode: 'value';
+    readonly value: {
+        id: string;
+        reference: string;
+    };
+}, "authorized", false, false>>;

package/dist/schema/modules/project/functions/receive-project-report.js

@@ -0,0 +1,10 @@
+import { method } from '@astrale-os/sdk/schema';
+import { receiveReportInput, reportReceiptValue } from '../../issue/index.js';
+import { ManageProject } from '../policies/manage-project.js';
+export const receiveProjectReportMethod = method({
+    description: 'Receive an idempotent report from a trusted Project owner integration, attributing its verified reporter without granting Project membership.',
+    auth: 'authorized',
+    policy: ({ check, self }) => check(ManageProject, self),
+    input: receiveReportInput,
+    output: reportReceiptValue,
+});

package/dist/schema/modules/tag/classes/tag.d.ts

@@ -5,9 +5,9 @@ export declare const Tag: import("@astrale-os/sdk/schema").AuthoredNodeClass<{
     readonly extends: readonly [import("@astrale-os/sdk/schema").KernelClass<"Named">, import("@astrale-os/sdk/schema").KernelClass<"Timestamped">];
     readonly properties: {
         slug: z.ZodString;
-        color: import("@astrale-os/sdk/schema").Property<z.ZodString, {
+        color: import("@astrale-os/sdk/schema").AuthoredProperty<z.ZodString, {
             readonly required: false;
-        }, never>;
+        }>;
     };
     readonly methods: {
         edit: import("@astrale-os/sdk/schema").Method<import("@astrale-os/sdk/schema").CallableProjection<{

package/dist/schema/schema.d.ts

@@ -8,9 +8,9 @@ export declare const schema: import("@astrale-os/sdk/schema").AuthoredSchema<"is
             readonly extends: readonly [import("@astrale-os/sdk/schema").KernelClass<"Named">, import("@astrale-os/sdk/schema").KernelClass<"Descriptable">, import("@astrale-os/sdk/schema").KernelClass<"Timestamped">];
             readonly properties: {
                 key: import("zod").ZodString;
-                ownerId: import("@astrale-os/sdk/schema").Property<import("zod").ZodString, {}, never>;
-                memberIds: import("@astrale-os/sdk/schema").Property<import("zod").ZodArray<import("zod").ZodString>, {}, never>;
-                nextIssueNumber: import("@astrale-os/sdk/schema").Property<import("zod").ZodNumber, {}, never>;
+                ownerId: import("@astrale-os/sdk/schema").AuthoredProperty<import("zod").ZodString, {}>;
+                memberIds: import("@astrale-os/sdk/schema").AuthoredProperty<import("zod").ZodArray<import("zod").ZodString>, {}>;
+                nextIssueNumber: import("@astrale-os/sdk/schema").AuthoredProperty<import("zod").ZodNumber, {}>;
                 archived: import("zod").ZodBoolean;
             };
             readonly methods: {
@@ -102,6 +102,106 @@ export declare const schema: import("@astrale-os/sdk/schema").AuthoredSchema<"is
                         archived: boolean;
                     };
                 }, "authorized", false, false>>;
+                receiveReport: import("@astrale-os/sdk/schema").Method<import("@astrale-os/sdk/schema").CallableProjection<{
+                    title: string;
+                    body: string;
+                    context?: {
+                        observedAt: string;
+                        cli: {
+                            version: string;
+                            platform: string;
+                            arch: string;
+                        };
+                        runtime: {
+                            node: string;
+                            bun?: string | undefined;
+                        };
+                        project?: {
+                            name: string;
+                            version?: string | undefined;
+                            packages: {
+                                name: string;
+                                declared?: string | undefined;
+                                version?: string | undefined;
+                                source: "installed" | "local" | "unresolved";
+                                commit?: string | undefined;
+                                dirty?: boolean | undefined;
+                            }[];
+                        } | undefined;
+                        instance?: {
+                            name: string;
+                            issuer?: string | undefined;
+                            url?: string | undefined;
+                        } | undefined;
+                    } | undefined;
+                    requestId: string;
+                    reporterId: string;
+                }, {
+                    readonly mode: 'value';
+                    readonly value: {
+                        id: string;
+                        reference: string;
+                    };
+                }, "authorized", false, false>>;
+                listReports: import("@astrale-os/sdk/schema").Method<import("@astrale-os/sdk/schema").CallableProjection<{
+                    pending?: boolean | undefined;
+                    cursor?: string | undefined;
+                }, {
+                    readonly mode: 'value';
+                    readonly value: {
+                        reports: {
+                            id: string;
+                            reference: string;
+                            reporterId: string;
+                            content: {
+                                title: string;
+                                body: string;
+                                context?: {
+                                    observedAt: string;
+                                    cli: {
+                                        version: string;
+                                        platform: string;
+                                        arch: string;
+                                    };
+                                    runtime: {
+                                        node: string;
+                                        bun?: string | undefined;
+                                    };
+                                    project?: {
+                                        name: string;
+                                        version?: string | undefined;
+                                        packages: {
+                                            name: string;
+                                            declared?: string | undefined;
+                                            version?: string | undefined;
+                                            source: "installed" | "local" | "unresolved";
+                                            commit?: string | undefined;
+                                            dirty?: boolean | undefined;
+                                        }[];
+                                    } | undefined;
+                                    instance?: {
+                                        name: string;
+                                        issuer?: string | undefined;
+                                        url?: string | undefined;
+                                    } | undefined;
+                                } | undefined;
+                            };
+                            pending: boolean;
+                            receivedAt: string;
+                        }[];
+                        cursor?: string | undefined;
+                    };
+                }, "authorized", false, false>>;
+                completeReport: import("@astrale-os/sdk/schema").Method<import("@astrale-os/sdk/schema").CallableProjection<{
+                    issueId: string;
+                    duplicateCandidateId?: string | undefined;
+                }, {
+                    readonly mode: 'value';
+                    readonly value: {
+                        issueId: string;
+                        changed: boolean;
+                    };
+                }, "authorized", false, false>>;
                 createTag: import("@astrale-os/sdk/schema").Method<import("@astrale-os/sdk/schema").CallableProjection<{
                     name: string;
                     color?: string | undefined;
@@ -132,8 +232,8 @@ export declare const schema: import("@astrale-os/sdk/schema").AuthoredSchema<"is
             readonly extends: readonly [import("@astrale-os/sdk/schema").KernelClass<"Named">, import("@astrale-os/sdk/schema").KernelClass<"Descriptable">, import("@astrale-os/sdk/schema").KernelClass<"Timestamped">];
             readonly properties: {
                 reference: import("zod").ZodString;
-                reporterId: import("@astrale-os/sdk/schema").Property<import("zod").ZodString, {}, never>;
-                assigneeId: import("@astrale-os/sdk/schema").Property<import("zod").ZodOptional<import("zod").ZodString>, {}, never>;
+                reporterId: import("@astrale-os/sdk/schema").AuthoredProperty<import("zod").ZodString, {}>;
+                assigneeId: import("@astrale-os/sdk/schema").AuthoredProperty<import("zod").ZodOptional<import("zod").ZodString>, {}>;
                 status: import("@astrale-os/sdk/schema").StateProperty<import("@astrale-os/sdk/schema").StateMachine<{
                     readonly open: {
                         readonly accept: "accepted";
@@ -163,6 +263,45 @@ export declare const schema: import("@astrale-os/sdk/schema").AuthoredSchema<"is
                 }>;
                 priority: import("zod").ZodNumber;
                 archived: import("zod").ZodBoolean;
+                reportRequestId: import("@astrale-os/sdk/schema").AuthoredProperty<import("zod").ZodOptional<import("zod").ZodString>, {}>;
+                report: import("@astrale-os/sdk/schema").AuthoredProperty<import("zod").ZodOptional<import("zod").ZodObject<{
+                    title: import("zod").ZodString;
+                    body: import("zod").ZodString;
+                    context: import("zod").ZodOptional<import("zod").ZodObject<{
+                        observedAt: import("zod").ZodString;
+                        cli: import("zod").ZodObject<{
+                            version: import("zod").ZodString;
+                            platform: import("zod").ZodString;
+                            arch: import("zod").ZodString;
+                        }, import("zod/v4/core").$strict>;
+                        runtime: import("zod").ZodObject<{
+                            node: import("zod").ZodString;
+                            bun: import("zod").ZodOptional<import("zod").ZodString>;
+                        }, import("zod/v4/core").$strict>;
+                        project: import("zod").ZodOptional<import("zod").ZodObject<{
+                            name: import("zod").ZodString;
+                            version: import("zod").ZodOptional<import("zod").ZodString>;
+                            packages: import("zod").ZodArray<import("zod").ZodObject<{
+                                name: import("zod").ZodString;
+                                declared: import("zod").ZodOptional<import("zod").ZodString>;
+                                version: import("zod").ZodOptional<import("zod").ZodString>;
+                                source: import("zod").ZodEnum<{
+                                    installed: "installed";
+                                    local: "local";
+                                    unresolved: "unresolved";
+                                }>;
+                                commit: import("zod").ZodOptional<import("zod").ZodString>;
+                                dirty: import("zod").ZodOptional<import("zod").ZodBoolean>;
+                            }, import("zod/v4/core").$strict>>;
+                        }, import("zod/v4/core").$strict>>;
+                        instance: import("zod").ZodOptional<import("zod").ZodObject<{
+                            name: import("zod").ZodString;
+                            issuer: import("zod").ZodOptional<import("zod").ZodString>;
+                            url: import("zod").ZodOptional<import("zod").ZodString>;
+                        }, import("zod/v4/core").$strict>>;
+                    }, import("zod/v4/core").$strict>>;
+                }, import("zod/v4/core").$strict>>, {}>;
+                reportPending: import("@astrale-os/sdk/schema").AuthoredProperty<import("zod").ZodOptional<import("zod").ZodBoolean>, {}>;
             };
             readonly methods: {
                 update: import("@astrale-os/sdk/schema").Method<import("@astrale-os/sdk/schema").CallableProjection<{
@@ -257,7 +396,7 @@ export declare const schema: import("@astrale-os/sdk/schema").AuthoredSchema<"is
             readonly extends: readonly [import("@astrale-os/sdk/schema").KernelClass<"Timestamped">];
             readonly properties: {
                 body: import("zod").ZodString;
-                authorId: import("@astrale-os/sdk/schema").Property<import("zod").ZodString, {}, never>;
+                authorId: import("@astrale-os/sdk/schema").AuthoredProperty<import("zod").ZodString, {}>;
             };
             readonly methods: {
                 edit: import("@astrale-os/sdk/schema").Method<import("@astrale-os/sdk/schema").CallableProjection<{
@@ -287,9 +426,9 @@ export declare const schema: import("@astrale-os/sdk/schema").AuthoredSchema<"is
             readonly extends: readonly [import("@astrale-os/sdk/schema").KernelClass<"Named">, import("@astrale-os/sdk/schema").KernelClass<"Timestamped">];
             readonly properties: {
                 slug: import("zod").ZodString;
-                color: import("@astrale-os/sdk/schema").Property<import("zod").ZodString, {
+                color: import("@astrale-os/sdk/schema").AuthoredProperty<import("zod").ZodString, {
                     readonly required: false;
-                }, never>;
+                }>;
             };
             readonly methods: {
                 edit: import("@astrale-os/sdk/schema").Method<import("@astrale-os/sdk/schema").CallableProjection<{
@@ -415,6 +554,24 @@ export declare const schema: import("@astrale-os/sdk/schema").AuthoredSchema<"is
             };
             readonly effectiveProperties: never;
         }>;
+        readonly issue_duplicate_candidate: import("@astrale-os/sdk/schema").DirectedEdgeClass<{
+            readonly depth: 0;
+            readonly abstract: false;
+            readonly extends: readonly [];
+            readonly properties: never;
+            readonly source: {
+                readonly as: "report";
+                readonly outgoing: "0..*";
+            };
+            readonly target: {
+                readonly as: "candidate";
+                readonly incoming: "0..*";
+            };
+            readonly constraints: {
+                readonly noSelf: true;
+            };
+            readonly effectiveProperties: never;
+        }>;
         readonly issue_has_comment: import("@astrale-os/sdk/schema").DirectedEdgeClass<{
             readonly depth: 0;
             readonly abstract: false;
@@ -483,6 +640,7 @@ export declare const schema: import("@astrale-os/sdk/schema").AuthoredSchema<"is
     readonly policies: {
         readonly ManageProject: import("@astrale-os/sdk/schema").Policy;
         readonly ContributeToProject: import("@astrale-os/sdk/schema").Policy;
+        readonly TraverseDuplicateCandidate: import("@astrale-os/sdk/schema").Policy;
         readonly ContributeToIssue: import("@astrale-os/sdk/schema").Policy;
         readonly ContributeToTag: import("@astrale-os/sdk/schema").Policy;
         readonly ManageTag: import("@astrale-os/sdk/schema").Policy;

package/dist/schema/schema.js

@@ -1,6 +1,6 @@
 import { KernelSchema, defineSchema, view } from '@astrale-os/sdk/schema';
 import { Comment, comment_authored_by, issue_has_comment, ContributeToComment, EditOwnComment, TraverseCommentRelationship, TraverseIssueComment, } from './modules/comment/index.js';
-import { Issue, ContributeToIssue, TraverseIssueAssignee, TraverseIssueParent, TraverseIssueReporter, TraverseProjectIssue, issue_assigned_to, issue_reported_by, issue_subtask_of, project_contains_issue, } from './modules/issue/index.js';
+import { Issue, issue_duplicate_candidate, TraverseDuplicateCandidate, ContributeToIssue, TraverseIssueAssignee, TraverseIssueParent, TraverseIssueReporter, TraverseProjectIssue, issue_assigned_to, issue_reported_by, issue_subtask_of, project_contains_issue, } from './modules/issue/index.js';
 import { Project, ContributeToProject, ManageProject, TraverseProjectMember, TraverseProjectOwner, project_has_member, project_owned_by, } from './modules/project/index.js';
 import { Tag, ContributeToTag, ManageTag, TraverseIssueTag, TraverseProjectTag, issue_tagged_with, project_contains_tag, } from './modules/tag/index.js';
 const origin = 'issues.astrale.ai';
@@ -15,6 +15,7 @@ const classes = {
     issue_reported_by,
     issue_assigned_to,
     issue_subtask_of,
+    issue_duplicate_candidate,
     issue_has_comment,
     comment_authored_by,
     project_contains_tag,
@@ -23,6 +24,7 @@ const classes = {
 const policies = {
     ManageProject,
     ContributeToProject,
+    TraverseDuplicateCandidate,
     ContributeToIssue,
     ContributeToTag,
     ManageTag,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@astrale-domains/issues",
-  "version": "0.3.2",
+  "version": "0.3.4",
   "repository": {
     "type": "git",
     "url": "git+https://github.com/astrale-os/domains.git",
@@ -28,15 +28,15 @@
     "registry": "https://registry.npmjs.org/"
   },
   "dependencies": {
-    "@astrale-os/sdk": "0.5.0-beta.128",
+    "@astrale-os/sdk": "0.6.0-beta.0",
     "zod": "4.4.3"
   },
   "devDependencies": {
-    "@astrale-os/adapter-cloudflare": "0.5.0-beta.131",
+    "@astrale-os/adapter-cloudflare": "0.5.0-beta.155",
     "@astrale-os/ox": ">=0.1.4 <1.0.0",
-    "@astrale-os/shell": "0.5.0-beta.16",
-    "@astrale-os/shell-react": "0.4.0-beta.15",
-    "@astrale-os/ui": "0.3.0-beta.25",
+    "@astrale-os/shell": "0.6.0-beta.3",
+    "@astrale-os/shell-react": "0.5.0-beta.3",
+    "@astrale-os/ui": "0.3.0-beta.31",
     "@tailwindcss/vite": "^4.3.3",
     "@tanstack/react-router": "1.170.18",
     "@tanstack/router-plugin": "1.168.23",
@@ -46,7 +46,7 @@
     "@types/react": "^19.2.18",
     "@types/react-dom": "^19.2.4",
     "@vitejs/plugin-react": "^6.1.0",
-    "bun": "1.4.0",
+    "bun": "1.4.2",
     "jsdom": "30.0.1",
     "mermaid": "^11.17.0",
     "oxlint": ">=1.79.0 <2.0.0",
@@ -58,7 +58,7 @@
     "type-fest": "^5.8.0",
     "typescript": "7.0.2",
     "vite": "^8.2.2",
-    "vitest": "^4.1.11"
+    "vitest": "^5.0.1"
   },
   "engines": {
     "node": ">=22.13"