@astrale-domains/issues 0.1.2 → 0.1.3

package/dist/schema/project/class.d.ts

@@ -0,0 +1,234 @@
+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 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<{
+        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">>, "addMember", "self"> | import("@astrale-os/sdk/schema").AuthoredMethodProjection<import("@astrale-os/sdk/schema").Method<import("@astrale-os/sdk/schema").CallableProjection<{
+        memberId: string;
+    }, {
+        readonly mode: 'value';
+        readonly value: {
+            projectId: string;
+            memberId: string;
+            changed: boolean;
+        };
+    }, "authorized", false, "default">>, "removeMember", "self"> | import("@astrale-os/sdk/schema").AuthoredMethodProjection<import("@astrale-os/sdk/schema").Method<import("@astrale-os/sdk/schema").CallableProjection<{
+        title: string;
+        description?: string | undefined;
+        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<{
+        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">;
+}>;

package/dist/schema/project/class.js

@@ -0,0 +1,27 @@
+import { K, nodeClass, property } from '@astrale-os/sdk/schema';
+import { z } from 'zod';
+import { nodeIdValue } from '../value/index.js';
+import { ContributeToProject } from './contribute-to-project-policy.js';
+import { addProjectMemberMethod, archiveProjectMethod, createProjectIssueMethod, createProjectMethod, createProjectTagMethod, removeProjectMemberMethod, updateProjectMethod, } from './methods.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, { visibility: 'private' }),
+        memberIds: property(z.array(nodeIdValue).max(256), { visibility: 'private' }),
+        nextIssueNumber: property(z.number().int().min(1), { visibility: 'private' }),
+        archived: z.boolean(),
+    },
+    methods: {
+        create: createProjectMethod,
+        update: updateProjectMethod,
+        addMember: addProjectMemberMethod,
+        removeMember: removeProjectMemberMethod,
+        createIssue: createProjectIssueMethod,
+        createTag: createProjectTagMethod,
+        archive: archiveProjectMethod,
+    },
+    policies: { read: () => ContributeToProject },
+});

package/dist/schema/project/contribute-to-project-policy.d.ts

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

package/dist/schema/project/contribute-to-project-policy.js

@@ -0,0 +1,6 @@
+import { policy } from '@astrale-os/sdk/schema';
+import { project_has_member, project_owned_by } from './relationships.js';
+export const ContributeToProject = policy({
+    description: 'The caller owns or is a member of this Project.',
+    match: ({ anyOf, edge, object, subject }) => anyOf(edge({ source: subject, class: () => project_owned_by, target: object }), edge({ source: subject, class: () => project_has_member, target: object })),
+});

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

@@ -0,0 +1,5 @@
+export { Project } from './class.js';
+export { ContributeToProject } from './contribute-to-project-policy.js';
+export { ManageProject } from './manage-project-policy.js';
+export { project_has_member, project_owned_by } from './relationships.js';
+export { TraverseProjectIssue, TraverseProjectMember, TraverseProjectOwner, TraverseProjectTag, } from './traverse-project-relationship-policy.js';

package/dist/schema/project/index.js

@@ -0,0 +1,5 @@
+export { Project } from './class.js';
+export { ContributeToProject } from './contribute-to-project-policy.js';
+export { ManageProject } from './manage-project-policy.js';
+export { project_has_member, project_owned_by } from './relationships.js';
+export { TraverseProjectIssue, TraverseProjectMember, TraverseProjectOwner, TraverseProjectTag, } from './traverse-project-relationship-policy.js';

package/dist/schema/project/manage-project-policy.d.ts

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

package/dist/schema/project/manage-project-policy.js

@@ -0,0 +1,6 @@
+import { policy } from '@astrale-os/sdk/schema';
+import { project_owned_by } from './relationships.js';
+export const ManageProject = policy({
+    description: 'The caller is the exact owner of this Project.',
+    match: ({ edge, object, subject }) => edge({ source: subject, class: () => project_owned_by, target: object }),
+});

package/dist/schema/project/methods.js

@@ -0,0 +1,68 @@
+import { method } from '@astrale-os/sdk/schema';
+import { z } from 'zod';
+import { issueValue, membershipChangeValue, nodeIdValue, projectValue, tagValue, } from '../value/index.js';
+import { ContributeToProject } from './contribute-to-project-policy.js';
+import { ManageProject } from './manage-project-policy.js';
+export const createProjectMethod = method({
+    description: 'Create one Project owned by the authenticated caller.',
+    static: true,
+    auth: 'authenticated',
+    input: z.strictObject({
+        key: z.string().min(1).max(40),
+        name: z.string().min(1).max(120),
+        description: z.string().max(5_000).optional(),
+    }),
+    output: projectValue,
+});
+export const updateProjectMethod = method({
+    description: 'Update mutable Project metadata.',
+    auth: 'authorized',
+    policy: ({ check, self }) => check(ManageProject, self),
+    input: z.strictObject({
+        name: z.string().min(1).max(120).optional(),
+        description: z.string().max(5_000).optional(),
+    }),
+    output: projectValue,
+});
+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,
+});
+export const removeProjectMemberMethod = method({
+    description: 'Remove one unassigned Identity from Project membership.',
+    auth: 'authorized',
+    policy: ({ check, self }) => check(ManageProject, self),
+    input: z.strictObject({ memberId: nodeIdValue }),
+    output: membershipChangeValue,
+});
+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,
+});
+export const createProjectTagMethod = method({
+    description: 'Create one Project-local Tag.',
+    auth: 'authorized',
+    policy: ({ check, self }) => check(ManageProject, self),
+    input: z.strictObject({
+        name: z.string().min(1).max(64),
+        color: z.string().optional(),
+    }),
+    output: tagValue,
+});
+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/{command → project}/relationships.d.ts

@@ -1,30 +1,30 @@
-export declare const command_requested_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: "command";
-        readonly outgoing: "1";
+        readonly as: "owner";
+        readonly outgoing: "0..*";
     };
     readonly target: {
-        readonly as: "requester";
-        readonly incoming: "0..*";
+        readonly as: "project";
+        readonly incoming: "1";
     };
     readonly constraints: Record<never, never>;
     readonly effectiveProperties: never;
 }>;
-export declare const command_targets_primary: import("@astrale-os/sdk/schema").DirectedEdgeClass<{
+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: "command";
-        readonly outgoing: "0..1";
+        readonly as: "member";
+        readonly outgoing: "0..*";
     };
     readonly target: {
-        readonly as: "primary";
+        readonly as: "project";
         readonly incoming: "0..*";
     };
     readonly constraints: Record<never, never>;

package/dist/schema/project/relationships.js

@@ -0,0 +1,15 @@
+import { K, edgeClass } from '@astrale-os/sdk/schema';
+import { Project } from './class.js';
+import { TraverseProjectMember, TraverseProjectOwner, } from './traverse-project-relationship-policy.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 },
+});
+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/project/traverse-project-relationship-policy.d.ts

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

package/dist/schema/project/traverse-project-relationship-policy.js

@@ -0,0 +1,20 @@
+import { policy } from '@astrale-os/sdk/schema';
+import { project_contains_issue } from '../issue/index.js';
+import { project_contains_tag } from '../tag/index.js';
+import { project_has_member, project_owned_by } from './relationships.js';
+export const TraverseProjectOwner = policy({
+    description: 'Project ownership is visible only to that Project owner and members.',
+    match: ({ allOf, anyOf, edge, source, subject, target }) => anyOf(allOf(edge({ source, class: () => project_owned_by, target }), edge({ source: subject, class: () => project_owned_by, target })), allOf(edge({ source, class: () => project_owned_by, target }), edge({ source: subject, class: () => project_has_member, target }))),
+});
+export const TraverseProjectMember = policy({
+    description: 'Project membership is visible only to that Project owner and members.',
+    match: ({ allOf, anyOf, edge, source, subject, target }) => anyOf(allOf(edge({ source, class: () => project_has_member, target }), edge({ source: subject, class: () => project_owned_by, target })), allOf(edge({ source, class: () => project_has_member, target }), edge({ source: subject, class: () => project_has_member, target }))),
+});
+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 }))),
+});
+export const TraverseProjectTag = policy({
+    description: 'Project Tag containment is visible only to that Project owner and members.',
+    match: ({ allOf, anyOf, edge, source, subject, target }) => anyOf(allOf(edge({ source, class: () => project_contains_tag, target }), edge({ source: subject, class: () => project_owned_by, target: source })), allOf(edge({ source, class: () => project_contains_tag, target }), edge({ source: subject, class: () => project_has_member, target: source }))),
+});