@astrale-domains/issues 0.3.2 → 0.3.4

package/README.md

@@ -1,7 +1,7 @@
 # Issues Domain
 
 `issues.astrale.ai` owns collaborative Projects, numbered Issues, Comments, and Project-local Tags.
-It is a current Astrale Application with Schema Policies, receiver Methods, atomic Mutations, and an
+It is an Astrale Application with Schema Policies, receiver Methods, atomic Mutations, and an
 inbox-first Shell View.
 
 The graph Schema depends only on Kernel: collaboration edges target any `Identity` subtype.
@@ -30,8 +30,8 @@ The public callable surface keeps observation Project-owned and mutations receiv
 ```text
 Project.create
 Project.list
-Project.update | addMember | removeMember | createIssue | createTag | archive
-Issue.update | assign | setTags | setParent | addComment | archive
+Project.update | addMember | removeMember | createIssue | receiveReport | listReports | completeReport | createTag | archive
+Issue.update | transition | assign | setTags | setParent | addComment | archive
 Comment.edit | delete
 Tag.edit | delete
 ```
@@ -54,12 +54,43 @@ collaboration state without requesting authority over every possible concrete Id
 another Domain.
 Those private execution fields are not a second public model and never replace the Policy edges.
 
-There is no Domain `Command`, receipt, universal idempotency layer, activity log, or undo system.
-`Project.create` and `Project.list` are Actions; the seventeen multi-step receiver operations are
-explicit Workflows whose Query and Mutation effects use stable steps. Set-style changes converge
-naturally and stale
-concurrent writes reject through atomic Mutation preconditions. Creation retries have no Domain
-replay guarantee; generic invocation idempotency belongs to the platform when it exists.
+`Project.receiveReport` is the owner-only intake for trusted integrations such as Admin. Its owner
+supplies a verified `reporterId`, an opaque `requestId`, `title`, `body`, and optional structured
+`context`. The public Admin facade must derive the reporter from authentication; ordinary senders
+must not receive this privileged owner capability or Project membership.
+
+One atomic mutation allocates the number, creates the Issue and reporter/containment edges, retains
+the original report, and sets `reportPending`. A query precondition fences the exact
+Project/reporter/request triple. A retry with identical content returns the original `{ id, reference }`,
+even after triage edits or archival; changed content under the same key is rejected. Independent
+request IDs remain independent reports. Known counter/key contention is retried up to eight attempts;
+unknown outcomes propagate, so the sender must retain the original payload and key until confirmation.
+The inline Workflow runner is not the source of durability: the graph receipt and atomic preconditions are.
+
+Context describes current client observations, separate from mutable Issue text. Missing versions and
+instance coordinates remain unknown. Creating a report does not grant access to this or other Issues.
+The generic domain has no Admin dependency. Admin setup, instance resolution, and scheduling remain
+integration-owned.
+
+The Project owner processes reports through two methods:
+
+- `Project.listReports({ pending?, cursor? })` returns up to 32 original reports, their reporters,
+  receipt times, and an opaque continuation cursor. Continue with the same pending filter. Omitting
+  the filter also includes completed originals. This method does not drain the collection.
+- `Project.completeReport({ issueId, duplicateCandidateId? })` acknowledges processing, optionally
+  adding one same-Project `issue_duplicate_candidate` edge in the same transaction. It preserves
+  all existing candidate edges, original evidence, and human edits. The edge is a triage suggestion,
+  not a merge. Traversal requires participation in the Project containing both endpoints.
+
+Completion guards the observed candidate set and pending state. Known concurrent changes reject
+without partial writes; the scheduler should reread and retry. Replaying a completed report returns
+`changed: false`, without applying a new candidate. Only acknowledge after integration-owned effects
+are durably recorded; those effects must also be idempotent because a worker can stop between them
+and acknowledgement. A failed report remains pending. An integration must resume pagination rather
+than repeatedly processing only the first page, so a persistent failure cannot starve later reports.
+
+Other creation methods retain their existing retry semantics. Set-style changes converge naturally;
+stale concurrent edits reject through atomic mutation preconditions.
 
 The mounted View defaults to a focused open-Issue Inbox with queue progress and keyboard or button
 navigation. Accepted work has a dedicated discussion view, while Browse searches and filters the

package/dist/schema/index.d.ts

@@ -1,6 +1,7 @@
 export { schema } from './schema.js';
 export type { IssuesDomain, IssuesSchema } from './schema.js';
 export { Project, project_has_member, project_owned_by } from './modules/project/index.js';
-export { Issue, issue_assigned_to, issue_reported_by, issue_subtask_of, project_contains_issue, } from './modules/issue/index.js';
+export { Issue, issue_assigned_to, issue_duplicate_candidate, issue_reported_by, issue_subtask_of, project_contains_issue, } from './modules/issue/index.js';
 export { Comment, comment_authored_by, issue_has_comment } from './modules/comment/index.js';
 export { Tag, issue_tagged_with, project_contains_tag } from './modules/tag/index.js';
+export { reportContentValue, reportContextValue, receiveReportInput, reportReceiptValue, reportRecordValue, reportPageValue, type ReportContent, } from './modules/issue/index.js';

package/dist/schema/index.js

@@ -1,5 +1,6 @@
 export { schema } from './schema.js';
 export { Project, project_has_member, project_owned_by } from './modules/project/index.js';
-export { Issue, issue_assigned_to, issue_reported_by, issue_subtask_of, project_contains_issue, } from './modules/issue/index.js';
+export { Issue, issue_assigned_to, issue_duplicate_candidate, issue_reported_by, issue_subtask_of, project_contains_issue, } from './modules/issue/index.js';
 export { Comment, comment_authored_by, issue_has_comment } from './modules/comment/index.js';
 export { Tag, issue_tagged_with, project_contains_tag } from './modules/tag/index.js';
+export { reportContentValue, reportContextValue, receiveReportInput, reportReceiptValue, reportRecordValue, reportPageValue, } from './modules/issue/index.js';

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

@@ -5,7 +5,7 @@ export declare const Comment: import("@astrale-os/sdk/schema").AuthoredNodeClass
     readonly extends: readonly [import("@astrale-os/sdk/schema").KernelClass<"Timestamped">];
     readonly properties: {
         body: z.ZodString;
-        authorId: import("@astrale-os/sdk/schema").Property<z.ZodString, {}, never>;
+        authorId: import("@astrale-os/sdk/schema").AuthoredProperty<z.ZodString, {}>;
     };
     readonly methods: {
         edit: import("@astrale-os/sdk/schema").Method<import("@astrale-os/sdk/schema").CallableProjection<{

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

@@ -3,3 +3,4 @@ export { issue_reported_by } from './issue-reported-by.js';
 export { issue_subtask_of } from './issue-subtask-of.js';
 export { Issue } from './issue.js';
 export { project_contains_issue } from './project-contains-issue.js';
+export { issue_duplicate_candidate } from './issue-duplicate-candidate.js';

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

@@ -3,3 +3,4 @@ export { issue_reported_by } from './issue-reported-by.js';
 export { issue_subtask_of } from './issue-subtask-of.js';
 export { Issue } from './issue.js';
 export { project_contains_issue } from './project-contains-issue.js';
+export { issue_duplicate_candidate } from './issue-duplicate-candidate.js';

package/dist/schema/modules/issue/classes/issue-duplicate-candidate.d.ts

@@ -0,0 +1,18 @@
+export declare const 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;
+}>;

package/dist/schema/modules/issue/classes/issue-duplicate-candidate.js

@@ -0,0 +1,10 @@
+import { edgeClass } from '@astrale-os/sdk/schema';
+import { TraverseDuplicateCandidate } from '../policies/traverse-duplicate-candidate.js';
+import { Issue } from './issue.js';
+export const issue_duplicate_candidate = edgeClass.directed({
+    description: 'A retained report may describe the same problem as another Issue; a suggestion for triage, not a merge or canonical identity.',
+    source: { as: 'report', accepts: [() => Issue], outgoing: '0..*' },
+    target: { as: 'candidate', accepts: [() => Issue], incoming: '0..*' },
+    constraints: { noSelf: true },
+    policies: { traverse: () => TraverseDuplicateCandidate },
+});

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

@@ -5,8 +5,8 @@ export declare const Issue: 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: {
         reference: z.ZodString;
-        reporterId: import("@astrale-os/sdk/schema").Property<z.ZodString, {}, never>;
-        assigneeId: import("@astrale-os/sdk/schema").Property<z.ZodOptional<z.ZodString>, {}, never>;
+        reporterId: import("@astrale-os/sdk/schema").AuthoredProperty<z.ZodString, {}>;
+        assigneeId: import("@astrale-os/sdk/schema").AuthoredProperty<z.ZodOptional<z.ZodString>, {}>;
         status: import("@astrale-os/sdk/schema").StateProperty<import("@astrale-os/sdk/schema").StateMachine<{
             readonly open: {
                 readonly accept: "accepted";
@@ -36,6 +36,45 @@ export declare const Issue: import("@astrale-os/sdk/schema").AuthoredNodeClass<{
         }>;
         priority: z.ZodNumber;
         archived: z.ZodBoolean;
+        reportRequestId: import("@astrale-os/sdk/schema").AuthoredProperty<z.ZodOptional<z.ZodString>, {}>;
+        report: import("@astrale-os/sdk/schema").AuthoredProperty<z.ZodOptional<z.ZodObject<{
+            title: z.ZodString;
+            body: z.ZodString;
+            context: z.ZodOptional<z.ZodObject<{
+                observedAt: z.ZodString;
+                cli: z.ZodObject<{
+                    version: z.ZodString;
+                    platform: z.ZodString;
+                    arch: z.ZodString;
+                }, z.core.$strict>;
+                runtime: z.ZodObject<{
+                    node: z.ZodString;
+                    bun: z.ZodOptional<z.ZodString>;
+                }, z.core.$strict>;
+                project: z.ZodOptional<z.ZodObject<{
+                    name: z.ZodString;
+                    version: z.ZodOptional<z.ZodString>;
+                    packages: z.ZodArray<z.ZodObject<{
+                        name: z.ZodString;
+                        declared: z.ZodOptional<z.ZodString>;
+                        version: z.ZodOptional<z.ZodString>;
+                        source: z.ZodEnum<{
+                            installed: "installed";
+                            local: "local";
+                            unresolved: "unresolved";
+                        }>;
+                        commit: z.ZodOptional<z.ZodString>;
+                        dirty: z.ZodOptional<z.ZodBoolean>;
+                    }, z.core.$strict>>;
+                }, z.core.$strict>>;
+                instance: z.ZodOptional<z.ZodObject<{
+                    name: z.ZodString;
+                    issuer: z.ZodOptional<z.ZodString>;
+                    url: z.ZodOptional<z.ZodString>;
+                }, z.core.$strict>>;
+            }, z.core.$strict>>;
+        }, z.core.$strict>>, {}>;
+        reportPending: import("@astrale-os/sdk/schema").AuthoredProperty<z.ZodOptional<z.ZodBoolean>, {}>;
     };
     readonly methods: {
         update: import("@astrale-os/sdk/schema").Method<import("@astrale-os/sdk/schema").CallableProjection<{

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

@@ -11,6 +11,7 @@ import { transitionIssueMethod } from '../functions/transition-issue.js';
 import { updateIssueMethod } from '../functions/update-issue.js';
 import { ContributeToIssue } from '../policies/contribute-to-issue.js';
 import { issueStatus } from '../states/index.js';
+import { reportContentValue } from '../types/report.js';
 export const Issue = nodeClass({
     description: 'One immutable-reference work item contained by exactly one Project.',
     icon: classIcon.lucide(CircleDot),
@@ -22,6 +23,9 @@ export const Issue = nodeClass({
         status: stateProperty(issueStatus),
         priority: z.number().int().min(0).max(4),
         archived: z.boolean(),
+        reportRequestId: property(z.string().min(1).max(128).optional(), {}),
+        report: property(reportContentValue.optional(), {}),
+        reportPending: property(z.boolean().optional(), {}),
     },
     methods: {
         update: updateIssueMethod,

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

@@ -1,5 +1,5 @@
-export { issueValue } from './types/index.js';
+export { issueValue, reportContentValue, reportContextValue, receiveReportInput, reportReceiptValue, reportRecordValue, reportPageValue, type ReportContent, } from './types/index.js';
 export { issueStatus, type IssueEvent, type IssueStatus } from './states/index.js';
-export { issue_assigned_to, issue_reported_by, issue_subtask_of, Issue, project_contains_issue, } from './classes/index.js';
+export { issue_assigned_to, issue_duplicate_candidate, 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';
+export { ContributeToIssue, TraverseDuplicateCandidate, TraverseIssueAssignee, TraverseIssueParent, TraverseIssueReporter, TraverseProjectIssue, } from './policies/index.js';

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

@@ -1,5 +1,5 @@
-export { issueValue } from './types/index.js';
+export { issueValue, reportContentValue, reportContextValue, receiveReportInput, reportReceiptValue, reportRecordValue, reportPageValue, } from './types/index.js';
 export { issueStatus } from './states/index.js';
-export { issue_assigned_to, issue_reported_by, issue_subtask_of, Issue, project_contains_issue, } from './classes/index.js';
+export { issue_assigned_to, issue_duplicate_candidate, 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';
+export { ContributeToIssue, TraverseDuplicateCandidate, TraverseIssueAssignee, TraverseIssueParent, TraverseIssueReporter, TraverseProjectIssue, } from './policies/index.js';

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

@@ -3,3 +3,4 @@ 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';
+export { TraverseDuplicateCandidate } from './traverse-duplicate-candidate.js';

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

@@ -3,3 +3,4 @@ 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';
+export { TraverseDuplicateCandidate } from './traverse-duplicate-candidate.js';

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

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

package/dist/schema/modules/issue/policies/traverse-duplicate-candidate.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 TraverseDuplicateCandidate = policy({
+    description: 'The caller participates in the Project containing both candidate duplicate Issues.',
+    match: ({ allOf, anyOf, edge, exists, source, target, subject }) => exists(({ node }) => {
+        const project = node(() => Project);
+        return allOf(edge({ source: project, class: () => project_contains_issue, target: source }), edge({ source: project, class: () => project_contains_issue, target }), anyOf(edge({ source: subject, class: () => project_owned_by, target: project }), edge({ source: subject, class: () => project_has_member, target: project })));
+    }),
+});

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

@@ -1 +1,2 @@
 export { issueValue } from './issue.js';
+export { reportContentValue, reportContextValue, receiveReportInput, reportReceiptValue, reportRecordValue, reportPageValue, type ReportContent, } from './report.js';

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

@@ -1 +1,2 @@
 export { issueValue } from './issue.js';
+export { reportContentValue, reportContextValue, receiveReportInput, reportReceiptValue, reportRecordValue, reportPageValue, } from './report.js';

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

@@ -0,0 +1,207 @@
+import { z } from 'zod';
+/** Observations at submission time; never evidence of a historical deployed build. */
+export declare const reportContextValue: z.ZodObject<{
+    observedAt: z.ZodString;
+    cli: z.ZodObject<{
+        version: z.ZodString;
+        platform: z.ZodString;
+        arch: z.ZodString;
+    }, z.core.$strict>;
+    runtime: z.ZodObject<{
+        node: z.ZodString;
+        bun: z.ZodOptional<z.ZodString>;
+    }, z.core.$strict>;
+    project: z.ZodOptional<z.ZodObject<{
+        name: z.ZodString;
+        version: z.ZodOptional<z.ZodString>;
+        packages: z.ZodArray<z.ZodObject<{
+            name: z.ZodString;
+            declared: z.ZodOptional<z.ZodString>;
+            version: z.ZodOptional<z.ZodString>;
+            source: z.ZodEnum<{
+                installed: "installed";
+                local: "local";
+                unresolved: "unresolved";
+            }>;
+            commit: z.ZodOptional<z.ZodString>;
+            dirty: z.ZodOptional<z.ZodBoolean>;
+        }, z.core.$strict>>;
+    }, z.core.$strict>>;
+    instance: z.ZodOptional<z.ZodObject<{
+        name: z.ZodString;
+        issuer: z.ZodOptional<z.ZodString>;
+        url: z.ZodOptional<z.ZodString>;
+    }, z.core.$strict>>;
+}, z.core.$strict>;
+export declare const reportContentValue: z.ZodObject<{
+    title: z.ZodString;
+    body: z.ZodString;
+    context: z.ZodOptional<z.ZodObject<{
+        observedAt: z.ZodString;
+        cli: z.ZodObject<{
+            version: z.ZodString;
+            platform: z.ZodString;
+            arch: z.ZodString;
+        }, z.core.$strict>;
+        runtime: z.ZodObject<{
+            node: z.ZodString;
+            bun: z.ZodOptional<z.ZodString>;
+        }, z.core.$strict>;
+        project: z.ZodOptional<z.ZodObject<{
+            name: z.ZodString;
+            version: z.ZodOptional<z.ZodString>;
+            packages: z.ZodArray<z.ZodObject<{
+                name: z.ZodString;
+                declared: z.ZodOptional<z.ZodString>;
+                version: z.ZodOptional<z.ZodString>;
+                source: z.ZodEnum<{
+                    installed: "installed";
+                    local: "local";
+                    unresolved: "unresolved";
+                }>;
+                commit: z.ZodOptional<z.ZodString>;
+                dirty: z.ZodOptional<z.ZodBoolean>;
+            }, z.core.$strict>>;
+        }, z.core.$strict>>;
+        instance: z.ZodOptional<z.ZodObject<{
+            name: z.ZodString;
+            issuer: z.ZodOptional<z.ZodString>;
+            url: z.ZodOptional<z.ZodString>;
+        }, z.core.$strict>>;
+    }, z.core.$strict>>;
+}, z.core.$strict>;
+export declare const receiveReportInput: z.ZodObject<{
+    title: z.ZodString;
+    body: z.ZodString;
+    context: z.ZodOptional<z.ZodObject<{
+        observedAt: z.ZodString;
+        cli: z.ZodObject<{
+            version: z.ZodString;
+            platform: z.ZodString;
+            arch: z.ZodString;
+        }, z.core.$strict>;
+        runtime: z.ZodObject<{
+            node: z.ZodString;
+            bun: z.ZodOptional<z.ZodString>;
+        }, z.core.$strict>;
+        project: z.ZodOptional<z.ZodObject<{
+            name: z.ZodString;
+            version: z.ZodOptional<z.ZodString>;
+            packages: z.ZodArray<z.ZodObject<{
+                name: z.ZodString;
+                declared: z.ZodOptional<z.ZodString>;
+                version: z.ZodOptional<z.ZodString>;
+                source: z.ZodEnum<{
+                    installed: "installed";
+                    local: "local";
+                    unresolved: "unresolved";
+                }>;
+                commit: z.ZodOptional<z.ZodString>;
+                dirty: z.ZodOptional<z.ZodBoolean>;
+            }, z.core.$strict>>;
+        }, z.core.$strict>>;
+        instance: z.ZodOptional<z.ZodObject<{
+            name: z.ZodString;
+            issuer: z.ZodOptional<z.ZodString>;
+            url: z.ZodOptional<z.ZodString>;
+        }, z.core.$strict>>;
+    }, z.core.$strict>>;
+    requestId: z.ZodString;
+    reporterId: z.ZodString;
+}, z.core.$strict>;
+export declare const reportReceiptValue: z.ZodObject<{
+    id: z.ZodString;
+    reference: z.ZodString;
+}, z.core.$strict>;
+export type ReportContent = z.infer<typeof reportContentValue>;
+export declare const reportRecordValue: z.ZodObject<{
+    id: z.ZodString;
+    reference: z.ZodString;
+    reporterId: z.ZodString;
+    content: z.ZodObject<{
+        title: z.ZodString;
+        body: z.ZodString;
+        context: z.ZodOptional<z.ZodObject<{
+            observedAt: z.ZodString;
+            cli: z.ZodObject<{
+                version: z.ZodString;
+                platform: z.ZodString;
+                arch: z.ZodString;
+            }, z.core.$strict>;
+            runtime: z.ZodObject<{
+                node: z.ZodString;
+                bun: z.ZodOptional<z.ZodString>;
+            }, z.core.$strict>;
+            project: z.ZodOptional<z.ZodObject<{
+                name: z.ZodString;
+                version: z.ZodOptional<z.ZodString>;
+                packages: z.ZodArray<z.ZodObject<{
+                    name: z.ZodString;
+                    declared: z.ZodOptional<z.ZodString>;
+                    version: z.ZodOptional<z.ZodString>;
+                    source: z.ZodEnum<{
+                        installed: "installed";
+                        local: "local";
+                        unresolved: "unresolved";
+                    }>;
+                    commit: z.ZodOptional<z.ZodString>;
+                    dirty: z.ZodOptional<z.ZodBoolean>;
+                }, z.core.$strict>>;
+            }, z.core.$strict>>;
+            instance: z.ZodOptional<z.ZodObject<{
+                name: z.ZodString;
+                issuer: z.ZodOptional<z.ZodString>;
+                url: z.ZodOptional<z.ZodString>;
+            }, z.core.$strict>>;
+        }, z.core.$strict>>;
+    }, z.core.$strict>;
+    pending: z.ZodBoolean;
+    receivedAt: z.ZodString;
+}, z.core.$strict>;
+export declare const reportPageValue: z.ZodObject<{
+    reports: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        reference: z.ZodString;
+        reporterId: z.ZodString;
+        content: z.ZodObject<{
+            title: z.ZodString;
+            body: z.ZodString;
+            context: z.ZodOptional<z.ZodObject<{
+                observedAt: z.ZodString;
+                cli: z.ZodObject<{
+                    version: z.ZodString;
+                    platform: z.ZodString;
+                    arch: z.ZodString;
+                }, z.core.$strict>;
+                runtime: z.ZodObject<{
+                    node: z.ZodString;
+                    bun: z.ZodOptional<z.ZodString>;
+                }, z.core.$strict>;
+                project: z.ZodOptional<z.ZodObject<{
+                    name: z.ZodString;
+                    version: z.ZodOptional<z.ZodString>;
+                    packages: z.ZodArray<z.ZodObject<{
+                        name: z.ZodString;
+                        declared: z.ZodOptional<z.ZodString>;
+                        version: z.ZodOptional<z.ZodString>;
+                        source: z.ZodEnum<{
+                            installed: "installed";
+                            local: "local";
+                            unresolved: "unresolved";
+                        }>;
+                        commit: z.ZodOptional<z.ZodString>;
+                        dirty: z.ZodOptional<z.ZodBoolean>;
+                    }, z.core.$strict>>;
+                }, z.core.$strict>>;
+                instance: z.ZodOptional<z.ZodObject<{
+                    name: z.ZodString;
+                    issuer: z.ZodOptional<z.ZodString>;
+                    url: z.ZodOptional<z.ZodString>;
+                }, z.core.$strict>>;
+            }, z.core.$strict>>;
+        }, z.core.$strict>;
+        pending: z.ZodBoolean;
+        receivedAt: z.ZodString;
+    }, z.core.$strict>>;
+    cursor: z.ZodOptional<z.ZodString>;
+}, z.core.$strict>;

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

@@ -0,0 +1,56 @@
+import { z } from 'zod';
+import { nodeIdValue } from '../../../types/index.js';
+const coordinate = z.string().min(1).max(2_048);
+const version = z.string().max(128);
+/** Observations at submission time; never evidence of a historical deployed build. */
+export const reportContextValue = z.strictObject({
+    observedAt: z.string().min(1).max(64),
+    cli: z.strictObject({ version, platform: z.string().max(64), arch: z.string().max(64) }),
+    runtime: z.strictObject({ node: version, bun: version.optional() }),
+    project: z
+        .strictObject({
+        name: z.string().max(200),
+        version: version.optional(),
+        packages: z
+            .array(z.strictObject({
+            name: z.string().min(1).max(200),
+            declared: z.string().max(128).optional(),
+            version: version.optional(),
+            source: z.enum(['installed', 'local', 'unresolved']),
+            commit: z.string().min(40).max(64).optional(),
+            dirty: z.boolean().optional(),
+        }))
+            .max(64),
+    })
+        .optional(),
+    instance: z
+        .strictObject({
+        name: z.string().max(200),
+        issuer: coordinate.optional(),
+        url: coordinate.optional(),
+    })
+        .optional(),
+});
+export const reportContentValue = z.strictObject({
+    title: z.string().min(1).max(200),
+    body: z.string().min(1).max(50_000),
+    context: reportContextValue.optional(),
+});
+export const receiveReportInput = reportContentValue.extend({
+    requestId: z.string().min(1).max(128),
+    reporterId: nodeIdValue,
+});
+export const reportReceiptValue = z.strictObject({
+    id: nodeIdValue,
+    reference: z.string().min(1).max(32),
+});
+export const reportRecordValue = reportReceiptValue.extend({
+    reporterId: nodeIdValue,
+    content: reportContentValue,
+    pending: z.boolean(),
+    receivedAt: z.string().min(1).max(64),
+});
+export const reportPageValue = z.strictObject({
+    reports: z.array(reportRecordValue).max(32),
+    cursor: z.string().optional(),
+});