@graview/core 0.1.0

package/dist/ops/types.d.ts

@@ -0,0 +1,52 @@
+import type { Primitive } from "../graph/primitives.js";
+import type { MutationCall } from "../mutations/types.js";
+export interface Author {
+    /**
+     * Who moved: a person, an agent acting on their behalf, a rule repairing
+     * something, or an external system of record whose change arrived here.
+     *
+     * `system` earns its place for the same reason the others do: an inbound
+     * calendar change is an ordinary op, appears in the activity list beside a
+     * person's edits, and is undone like anything else. A sync layer that wrote
+     * the graph outside the log would be the one kind of change nobody could
+     * see or take back.
+     */
+    readonly kind: "human" | "agent" | "rule" | "system";
+    readonly id?: string;
+    readonly session?: string;
+}
+/**
+ * One entry in the append-only log. The graph is a fold over these.
+ *
+ * `reads` is what turns undo from a stack into a dependency graph, and it
+ * has to be captured when the op runs — historical reads are not
+ * recoverable, so this field can never be backfilled.
+ */
+export interface Operation {
+    readonly id: string;
+    /** Monotonic position in the log. */
+    readonly seq: number;
+    /** One user gesture, or one agent turn. */
+    readonly batch: string;
+    readonly author: Author;
+    /** Human-readable statement of what was meant, not what changed. */
+    readonly intent: string;
+    readonly mutation: MutationCall | null;
+    readonly primitives: readonly Primitive[];
+    readonly inverse: readonly Primitive[];
+    readonly reads: readonly string[];
+    readonly writes: readonly string[];
+    readonly at: string;
+    /** Set when this op exists to undo another one. */
+    readonly undoes?: string;
+}
+export interface Batch {
+    readonly id: string;
+    readonly author: Author;
+    readonly intent: string;
+    readonly at: string;
+    readonly ops: readonly Operation[];
+    /** True when every op in the batch has been inverted by a later op. */
+    readonly undone: boolean;
+}
+//# sourceMappingURL=types.d.ts.map

package/dist/ops/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../src/ops/types.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,wBAAwB,CAAC;AACxD,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,uBAAuB,CAAC;AAE1D,MAAM,WAAW,MAAM;IACrB;;;;;;;;;OASG;IACH,QAAQ,CAAC,IAAI,EAAE,OAAO,GAAG,OAAO,GAAG,MAAM,GAAG,QAAQ,CAAC;IACrD,QAAQ,CAAC,EAAE,CAAC,EAAE,MAAM,CAAC;IACrB,QAAQ,CAAC,OAAO,CAAC,EAAE,MAAM,CAAC;CAC3B;AAED;;;;;;GAMG;AACH,MAAM,WAAW,SAAS;IACxB,QAAQ,CAAC,EAAE,EAAE,MAAM,CAAC;IACpB,qCAAqC;IACrC,QAAQ,CAAC,GAAG,EAAE,MAAM,CAAC;IACrB,2CAA2C;IAC3C,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;IACvB,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;IACxB,oEAAoE;IACpE,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;IACxB,QAAQ,CAAC,QAAQ,EAAE,YAAY,GAAG,IAAI,CAAC;IACvC,QAAQ,CAAC,UAAU,EAAE,SAAS,SAAS,EAAE,CAAC;IAC1C,QAAQ,CAAC,OAAO,EAAE,SAAS,SAAS,EAAE,CAAC;IACvC,QAAQ,CAAC,KAAK,EAAE,SAAS,MAAM,EAAE,CAAC;IAClC,QAAQ,CAAC,MAAM,EAAE,SAAS,MAAM,EAAE,CAAC;IACnC,QAAQ,CAAC,EAAE,EAAE,MAAM,CAAC;IACpB,mDAAmD;IACnD,QAAQ,CAAC,MAAM,CAAC,EAAE,MAAM,CAAC;CAC1B;AAED,MAAM,WAAW,KAAK;IACpB,QAAQ,CAAC,EAAE,EAAE,MAAM,CAAC;IACpB,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;IACxB,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;IACxB,QAAQ,CAAC,EAAE,EAAE,MAAM,CAAC;IACpB,QAAQ,CAAC,GAAG,EAAE,SAAS,SAAS,EAAE,CAAC;IACnC,uEAAuE;IACvE,QAAQ,CAAC,MAAM,EAAE,OAAO,CAAC;CAC1B"}

package/dist/ops/types.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=types.js.map

package/dist/ops/types.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.js","sourceRoot":"","sources":["../../src/ops/types.ts"],"names":[],"mappings":""}

package/dist/ops/undo.d.ts

@@ -0,0 +1,33 @@
+import type { OperationLog } from "./log.js";
+import type { Operation } from "./types.js";
+export interface UndoBlock {
+    /** The op that read something the undo target wrote. */
+    readonly op: Operation;
+    /** The node ids it read that the target wrote. */
+    readonly overlap: readonly string[];
+}
+export type UndoCheck = {
+    readonly ok: true;
+    readonly ops: readonly Operation[];
+} | {
+    readonly ok: false;
+    readonly ops: readonly Operation[];
+    readonly blockedBy: readonly UndoBlock[];
+    /** Batches that would have to come along for the undo to be legal. */
+    readonly includeBatches: readonly string[];
+    readonly message: string;
+};
+/**
+ * Undoing an op out of order is legal exactly when no later live op read
+ * something it wrote. That is a checkable condition rather than a policy —
+ * so when it fails the framework can name the blocking op and offer to bring
+ * it along, instead of refusing or corrupting state.
+ */
+export declare function checkUndo(log: OperationLog, batchIds: readonly string[]): UndoCheck;
+/**
+ * The primitives an undo would apply: each op's stored inverse, newest first,
+ * so dependent writes come apart in the order they went together. (An op's
+ * `inverse` is already reversed internally when the op is recorded.)
+ */
+export declare function undoPrimitives(ops: readonly Operation[]): import("../index.js").Primitive[];
+//# sourceMappingURL=undo.d.ts.map

package/dist/ops/undo.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"undo.d.ts","sourceRoot":"","sources":["../../src/ops/undo.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,UAAU,CAAC;AAC7C,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,YAAY,CAAC;AAE5C,MAAM,WAAW,SAAS;IACxB,wDAAwD;IACxD,QAAQ,CAAC,EAAE,EAAE,SAAS,CAAC;IACvB,kDAAkD;IAClD,QAAQ,CAAC,OAAO,EAAE,SAAS,MAAM,EAAE,CAAC;CACrC;AAED,MAAM,MAAM,SAAS,GACjB;IAAE,QAAQ,CAAC,EAAE,EAAE,IAAI,CAAC;IAAC,QAAQ,CAAC,GAAG,EAAE,SAAS,SAAS,EAAE,CAAA;CAAE,GACzD;IACE,QAAQ,CAAC,EAAE,EAAE,KAAK,CAAC;IACnB,QAAQ,CAAC,GAAG,EAAE,SAAS,SAAS,EAAE,CAAC;IACnC,QAAQ,CAAC,SAAS,EAAE,SAAS,SAAS,EAAE,CAAC;IACzC,sEAAsE;IACtE,QAAQ,CAAC,cAAc,EAAE,SAAS,MAAM,EAAE,CAAC;IAC3C,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC;CAC1B,CAAC;AAEN;;;;;GAKG;AACH,wBAAgB,SAAS,CACvB,GAAG,EAAE,YAAY,EACjB,QAAQ,EAAE,SAAS,MAAM,EAAE,GAC1B,SAAS,CAgDX;AAED;;;;GAIG;AACH,wBAAgB,cAAc,CAAC,GAAG,EAAE,SAAS,SAAS,EAAE,qCAEvD"}

package/dist/ops/undo.js

@@ -0,0 +1,65 @@
+/**
+ * Undoing an op out of order is legal exactly when no later live op read
+ * something it wrote. That is a checkable condition rather than a policy —
+ * so when it fails the framework can name the blocking op and offer to bring
+ * it along, instead of refusing or corrupting state.
+ */
+export function checkUndo(log, batchIds) {
+    const targets = new Set(batchIds);
+    const undone = log.undoneIds();
+    const ops = log
+        .all()
+        .filter((op) => targets.has(op.batch) && !undone.has(op.id));
+    if (ops.length === 0) {
+        return {
+            ok: false,
+            ops,
+            blockedBy: [],
+            includeBatches: [],
+            message: batchIds.length === 0
+                ? "No batch given to undo"
+                : `Nothing live to undo in ${batchIds.join(", ")} — already undone, or never applied`,
+        };
+    }
+    const writes = new Set();
+    for (const op of ops)
+        for (const id of op.writes)
+            writes.add(id);
+    const earliest = Math.min(...ops.map((op) => op.seq));
+    const blockedBy = [];
+    for (const op of log.all()) {
+        if (op.seq <= earliest)
+            continue;
+        if (targets.has(op.batch))
+            continue;
+        if (undone.has(op.id))
+            continue;
+        const overlap = op.reads.filter((id) => writes.has(id));
+        if (overlap.length > 0)
+            blockedBy.push({ op, overlap });
+    }
+    if (blockedBy.length === 0)
+        return { ok: true, ops };
+    const includeBatches = [...new Set(blockedBy.map((b) => b.op.batch))];
+    const named = blockedBy
+        .map((b) => `"${b.op.intent}" (op ${b.op.id}, read ${b.overlap.join(", ")})`)
+        .join("; ");
+    return {
+        ok: false,
+        ops,
+        blockedBy,
+        includeBatches,
+        message: `Cannot undo on its own — a later operation depends on it: ${named}. Include ${includeBatches
+            .map((id) => `batch ${id}`)
+            .join(", ")} to undo them together.`,
+    };
+}
+/**
+ * The primitives an undo would apply: each op's stored inverse, newest first,
+ * so dependent writes come apart in the order they went together. (An op's
+ * `inverse` is already reversed internally when the op is recorded.)
+ */
+export function undoPrimitives(ops) {
+    return [...ops].sort((a, b) => b.seq - a.seq).flatMap((op) => op.inverse);
+}
+//# sourceMappingURL=undo.js.map

package/dist/ops/undo.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"undo.js","sourceRoot":"","sources":["../../src/ops/undo.ts"],"names":[],"mappings":"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"}

package/dist/permissions/policy.d.ts

@@ -0,0 +1,68 @@
+import type { AnyMutationDefinition } from "../mutations/types.js";
+import type { AnySchema } from "../schema/schema.js";
+import type { Policy, Principal, Refusal } from "./types.js";
+/**
+ * WHAT A REFUSAL CALLS THINGS. The policy knows acts and roles by their
+ * names; a person reads "Not permitted: close-deal on a deal — sales-manager
+ * can" struck through beside every button they may not press. The store
+ * hands its titles and nouns ("“Close the deal” on a deal — a sales manager
+ * can"); a role is always said in words.
+ */
+export interface PolicyWords {
+    readonly act?: (mutation: string) => string | undefined;
+    readonly noun?: (kind: string) => string;
+}
+/**
+ * Whether a principal may run a mutation, and if not, who could.
+ *
+ * `kind` is the subject's kind when the call names one. A grant restricted by
+ * kind and a call whose subject cannot be resolved is refused rather than
+ * allowed: the safe reading of "I could not tell what this acts on" is no.
+ */
+export declare function permits(policy: Policy | undefined, principal: Principal, mutation: string, kind?: string, 
+/**
+ * Declared mutations any ONE of which being permitted permits this one.
+ * How a derived edit act is judged: whoever may already change or make a
+ * kind may change what was set when it was made — the policy's own grants,
+ * read again, rather than a second list.
+ */
+via?: readonly string[], 
+/**
+ * The id of the node the call acts on, when it names one. A `self` grant
+ * is only ever satisfied when this is the principal's own id.
+ */
+subjectId?: string, 
+/** How the refusal names an act and a kind: the store hands its titles and nouns. */
+words?: PolicyWords): {
+    readonly ok: true;
+} | {
+    readonly ok: false;
+    readonly refusal: Refusal;
+};
+/**
+ * WHY, IN THE POLICY'S OWN WORDS.
+ *
+ * A grant carries a `describe` — documented from the day it was added as
+ * "shown when an action is withheld, so a refusal can say something useful"
+ * — and nothing read it. Every refusal in every surface was assembled from a
+ * mutation id and a list of role names, which is what the declaration says,
+ * not what the organisation means. The sentences of the grants that WOULD
+ * allow this are the ones worth repeating.
+ */
+export declare function whyNot(policy: Policy, mutation: string, kind?: string): readonly string[];
+/**
+ * Every role that could run this mutation, so a refusal can name what would
+ * be needed instead of merely saying no.
+ */
+export declare function rolesWhoCould(policy: Policy, mutation: string, kind?: string): readonly string[];
+/** Every role the policy mentions, declared or implied by its grants. */
+export declare function rolesOf(policy: Policy): readonly string[];
+/**
+ * The mutations a principal may run at all, ignoring any particular subject.
+ *
+ * This is what narrows an agent seat's generated tool schema: a seat holding
+ * a principal gets tools for what that principal can do, and there is no
+ * second list to keep in step.
+ */
+export declare function permittedMutations<S extends AnySchema>(policy: Policy | undefined, principal: Principal, mutations: readonly AnyMutationDefinition<S>[]): readonly AnyMutationDefinition<S>[];
+//# sourceMappingURL=policy.d.ts.map

package/dist/permissions/policy.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"policy.d.ts","sourceRoot":"","sources":["../../src/permissions/policy.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,qBAAqB,EAAE,MAAM,uBAAuB,CAAC;AACnE,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,qBAAqB,CAAC;AAErD,OAAO,KAAK,EAAS,MAAM,EAAE,SAAS,EAAE,OAAO,EAAE,MAAM,YAAY,CAAC;AAWpE;;;;;;GAMG;AACH,MAAM,WAAW,WAAW;IAC1B,QAAQ,CAAC,GAAG,CAAC,EAAE,CAAC,QAAQ,EAAE,MAAM,KAAK,MAAM,GAAG,SAAS,CAAC;IACxD,QAAQ,CAAC,IAAI,CAAC,EAAE,CAAC,IAAI,EAAE,MAAM,KAAK,MAAM,CAAC;CAC1C;AAQD;;;;;;GAMG;AACH,wBAAgB,OAAO,CACrB,MAAM,EAAE,MAAM,GAAG,SAAS,EAC1B,SAAS,EAAE,SAAS,EACpB,QAAQ,EAAE,MAAM,EAChB,IAAI,CAAC,EAAE,MAAM;AACb;;;;;GAKG;AACH,GAAG,CAAC,EAAE,SAAS,MAAM,EAAE;AACvB;;;GAGG;AACH,SAAS,CAAC,EAAE,MAAM;AAClB,qFAAqF;AACrF,KAAK,GAAE,WAAgB,GACtB;IAAE,QAAQ,CAAC,EAAE,EAAE,IAAI,CAAA;CAAE,GAAG;IAAE,QAAQ,CAAC,EAAE,EAAE,KAAK,CAAC;IAAC,QAAQ,CAAC,OAAO,EAAE,OAAO,CAAA;CAAE,CA8D3E;AAwBD;;;;;;;;;GASG;AACH,wBAAgB,MAAM,CAAC,MAAM,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,EAAE,IAAI,CAAC,EAAE,MAAM,GAAG,SAAS,MAAM,EAAE,CAUzF;AAED;;;GAGG;AACH,wBAAgB,aAAa,CAC3B,MAAM,EAAE,MAAM,EACd,QAAQ,EAAE,MAAM,EAChB,IAAI,CAAC,EAAE,MAAM,GACZ,SAAS,MAAM,EAAE,CAcnB;AAED,yEAAyE;AACzE,wBAAgB,OAAO,CAAC,MAAM,EAAE,MAAM,GAAG,SAAS,MAAM,EAAE,CAQzD;AAED;;;;;;GAMG;AACH,wBAAgB,kBAAkB,CAAC,CAAC,SAAS,SAAS,EACpD,MAAM,EAAE,MAAM,GAAG,SAAS,EAC1B,SAAS,EAAE,SAAS,EACpB,SAAS,EAAE,SAAS,qBAAqB,CAAC,CAAC,CAAC,EAAE,GAC7C,SAAS,qBAAqB,CAAC,CAAC,CAAC,EAAE,CAUrC"}

package/dist/permissions/policy.js

@@ -0,0 +1,191 @@
+import { humaniseField, withArticle } from "../schema/define-node.js";
+const matches = (allowed, value) => allowed === "*" || allowed.includes(value);
+/** Whether a grant covers a principal at all, before looking at the call. */
+function grantsTo(grant, principal) {
+    if (grant.roles === "*")
+        return true;
+    return (principal.roles ?? []).some((role) => grant.roles.includes(role));
+}
+/** "a sales manager", "a sales manager or a salesperson". */
+function rolesSaid(roles) {
+    const spoken = roles.map((role) => withArticle(humaniseField(role).toLowerCase()));
+    return spoken.length <= 1 ? (spoken[0] ?? "") : `${spoken.slice(0, -1).join(", ")} or ${spoken[spoken.length - 1]}`;
+}
+/**
+ * Whether a principal may run a mutation, and if not, who could.
+ *
+ * `kind` is the subject's kind when the call names one. A grant restricted by
+ * kind and a call whose subject cannot be resolved is refused rather than
+ * allowed: the safe reading of "I could not tell what this acts on" is no.
+ */
+export function permits(policy, principal, mutation, kind, 
+/**
+ * Declared mutations any ONE of which being permitted permits this one.
+ * How a derived edit act is judged: whoever may already change or make a
+ * kind may change what was set when it was made — the policy's own grants,
+ * read again, rather than a second list.
+ */
+via, 
+/**
+ * The id of the node the call acts on, when it names one. A `self` grant
+ * is only ever satisfied when this is the principal's own id.
+ */
+subjectId, 
+/** How the refusal names an act and a kind: the store hands its titles and nouns. */
+words = {}) {
+    // No policy means permission is not a concern in this installation.
+    if (!policy)
+        return { ok: true };
+    /*
+     * A derived act is permitted when the policy names it (or says `*`) —
+     * the grants are read first, as for any act — and otherwise when any of
+     * the declared acts it rides is permitted for this principal on this kind.
+     */
+    if (via !== undefined) {
+        if (permits(policy, principal, mutation, kind, undefined, subjectId).ok)
+            return { ok: true };
+        if (via.some((name) => permits(policy, principal, name, kind, undefined, subjectId).ok))
+            return { ok: true };
+        /*
+         * A derived edit is reachable two ways, and the refusal has to count
+         * both: a grant naming it (or saying `*`), and a grant on any declared
+         * act it rides. Counting only the second said "no declared act writes or
+         * creates it, so no role can" to a rider while the driver's `mutations:
+         * "*"` grant plainly reached it.
+         */
+        const names = [mutation, ...via];
+        const wouldNeed = [
+            ...new Set(names.flatMap((name) => rolesWhoCould(policy, name, kind))),
+        ].sort();
+        const who = wouldNeed.length === 0
+            ? via.length === 0
+                ? "no declared act creates or changes it, so no role can"
+                : "no role can"
+            : `${rolesSaid(wouldNeed)} can`;
+        return {
+            ok: false,
+            refusal: {
+                mutation,
+                ...(kind === undefined ? {} : { kind }),
+                wouldNeed,
+                message: said(policy, names, kind, who, words),
+            },
+        };
+    }
+    for (const grant of policy.grants) {
+        if (!grantsTo(grant, principal))
+            continue;
+        if (!matches(grant.mutations, mutation))
+            continue;
+        if (grant.kinds !== undefined && grant.kinds !== "*") {
+            if (kind === undefined || !grant.kinds.includes(kind))
+                continue;
+        }
+        // "You, on yours": a self grant needs the subject to be the principal.
+        if (grant.self && (subjectId === undefined || principal.id === undefined || subjectId !== principal.id))
+            continue;
+        return { ok: true };
+    }
+    const wouldNeed = rolesWhoCould(policy, mutation, kind);
+    const who = wouldNeed.length === 0 ? "no role can" : `${rolesSaid(wouldNeed)} can`;
+    return {
+        ok: false,
+        refusal: {
+            mutation,
+            ...(kind === undefined ? {} : { kind }),
+            wouldNeed,
+            message: said(policy, [mutation], kind, who, words),
+        },
+    };
+}
+/**
+ * The refusal in words: what it was, who could, and why the policy says so.
+ *
+ * `names` is every act that would have reached this one, because a derived
+ * edit rides the acts that write its fields — and the sentence has to come
+ * from the same grants the roles did, or the two halves contradict.
+ */
+function said(policy, names, kind, who, words) {
+    const because = [...new Set(names.flatMap((name) => whyNot(policy, name, kind)))];
+    const act = words.act?.(names[0]);
+    return (`Not permitted: ${act ? `“${act}”` : names[0]}${kind ? ` on ${withArticle(words.noun?.(kind) ?? kind)}` : ""} — ${who}.` +
+        (because.length > 0 ? ` ${because.join(" ")}` : ""));
+}
+/**
+ * WHY, IN THE POLICY'S OWN WORDS.
+ *
+ * A grant carries a `describe` — documented from the day it was added as
+ * "shown when an action is withheld, so a refusal can say something useful"
+ * — and nothing read it. Every refusal in every surface was assembled from a
+ * mutation id and a list of role names, which is what the declaration says,
+ * not what the organisation means. The sentences of the grants that WOULD
+ * allow this are the ones worth repeating.
+ */
+export function whyNot(policy, mutation, kind) {
+    const said = new Set();
+    for (const grant of policy.grants) {
+        if (!matches(grant.mutations, mutation))
+            continue;
+        if (grant.kinds !== undefined && grant.kinds !== "*" && kind !== undefined) {
+            if (!grant.kinds.includes(kind))
+                continue;
+        }
+        if (grant.describe)
+            said.add(grant.describe);
+    }
+    return [...said];
+}
+/**
+ * Every role that could run this mutation, so a refusal can name what would
+ * be needed instead of merely saying no.
+ */
+export function rolesWhoCould(policy, mutation, kind) {
+    const roles = new Set();
+    for (const grant of policy.grants) {
+        if (!matches(grant.mutations, mutation))
+            continue;
+        if (grant.kinds !== undefined && grant.kinds !== "*" && kind !== undefined) {
+            if (!grant.kinds.includes(kind))
+                continue;
+        }
+        if (grant.roles === "*") {
+            // Everyone already may; naming roles would be misleading.
+            return [];
+        }
+        for (const role of grant.roles)
+            roles.add(role);
+    }
+    return [...roles].sort();
+}
+/** Every role the policy mentions, declared or implied by its grants. */
+export function rolesOf(policy) {
+    if (policy.roles)
+        return policy.roles;
+    const roles = new Set();
+    for (const grant of policy.grants) {
+        if (grant.roles === "*")
+            continue;
+        for (const role of grant.roles)
+            roles.add(role);
+    }
+    return [...roles].sort();
+}
+/**
+ * The mutations a principal may run at all, ignoring any particular subject.
+ *
+ * This is what narrows an agent seat's generated tool schema: a seat holding
+ * a principal gets tools for what that principal can do, and there is no
+ * second list to keep in step.
+ */
+export function permittedMutations(policy, principal, mutations) {
+    if (!policy)
+        return mutations;
+    return mutations.filter((mutation) => {
+        const subject = mutation.subject;
+        const kinds = subject && subject.kinds !== "*" ? subject.kinds : [undefined];
+        // Permitted for ANY of its subject kinds is enough to offer the tool; the
+        // store still refuses the individual call that is not allowed.
+        return kinds.some((kind) => permits(policy, principal, mutation.name, kind).ok);
+    });
+}
+//# sourceMappingURL=policy.js.map

package/dist/permissions/policy.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"policy.js","sourceRoot":"","sources":["../../src/permissions/policy.ts"],"names":[],"mappings":"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"}

package/dist/permissions/types.d.ts

@@ -0,0 +1,78 @@
+import type { Author } from "../ops/types.js";
+/**
+ * Who is acting, and what they are allowed to be.
+ *
+ * A principal IS an author with roles. Attribution and authorisation are the
+ * same fact seen twice, not two systems: every op already records `{ kind,
+ * id, session }`, so adding roles to that shape means the thing the log
+ * blames is the thing the policy judged, by construction. There is no way to
+ * act as one participant and be authorised as another.
+ */
+export interface Principal extends Author {
+    readonly roles?: readonly string[];
+}
+/**
+ * One permission: these roles may run these mutations, optionally only
+ * against subjects of certain kinds.
+ *
+ * Deliberately small. A grant is a fact about the declaration — mutation
+ * names and node kinds, both of which `graview check` can see — so "a
+ * mutation no role can ever run" and "a role that may do nothing" are
+ * build-time findings rather than things discovered by a person who cannot
+ * press a button.
+ */
+export interface Grant {
+    /** Roles this grant is for. `"*"` means everyone, including no roles at all. */
+    readonly roles: readonly string[] | "*";
+    readonly mutations: readonly string[] | "*";
+    /** Restricts the grant to subjects of these kinds. Defaults to all of them. */
+    readonly kinds?: readonly string[] | "*";
+    /** Shown when an action is withheld, so a refusal can say something useful. */
+    readonly describe?: string;
+    /**
+     * Only on the principal's OWN record: the call's subject must be the node
+     * whose id is the principal's. This is how a person edits their profile
+     * without a role that edits everyone's — the grant reads "you, on yours".
+     */
+    readonly self?: boolean;
+}
+/**
+ * A policy is deny-by-default, and its ABSENCE permits everything.
+ *
+ * The second half matters as much as the first: a store with no policy is not
+ * a store where nothing works, it is a store where permission is not a
+ * concern yet. An app opts in by declaring one.
+ */
+export interface Policy {
+    readonly grants: readonly Grant[];
+    /**
+     * Roles the policy knows about, so `graview check` can report a role that
+     * may do nothing. Derived from the grants when absent.
+     */
+    readonly roles?: readonly string[];
+}
+/** Why an action is not available, in terms someone can act on. */
+export interface Refusal {
+    readonly mutation: string;
+    /** The subject kind that was refused, when the call names one. */
+    readonly kind?: string;
+    readonly message: string;
+    /**
+     * The roles that WOULD be allowed to do it. Empty means nobody can, which
+     * is a different problem and says so.
+     */
+    readonly wouldNeed: readonly string[];
+}
+/**
+ * Thrown when a principal runs a mutation they may not.
+ *
+ * An error rather than a silent no-op: enforcement lives at the store, and a
+ * store that quietly did nothing would be indistinguishable from one that
+ * worked. Every caller — a person's click, an agent's tool call, a sync
+ * adapter's inbound change — hits the same wall in the same way.
+ */
+export declare class PermissionDeniedError extends Error {
+    readonly refusal: Refusal;
+    constructor(refusal: Refusal);
+}
+//# sourceMappingURL=types.d.ts.map

package/dist/permissions/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../src/permissions/types.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,iBAAiB,CAAC;AAE9C;;;;;;;;GAQG;AACH,MAAM,WAAW,SAAU,SAAQ,MAAM;IACvC,QAAQ,CAAC,KAAK,CAAC,EAAE,SAAS,MAAM,EAAE,CAAC;CACpC;AAED;;;;;;;;;GASG;AACH,MAAM,WAAW,KAAK;IACpB,gFAAgF;IAChF,QAAQ,CAAC,KAAK,EAAE,SAAS,MAAM,EAAE,GAAG,GAAG,CAAC;IACxC,QAAQ,CAAC,SAAS,EAAE,SAAS,MAAM,EAAE,GAAG,GAAG,CAAC;IAC5C,+EAA+E;IAC/E,QAAQ,CAAC,KAAK,CAAC,EAAE,SAAS,MAAM,EAAE,GAAG,GAAG,CAAC;IACzC,+EAA+E;IAC/E,QAAQ,CAAC,QAAQ,CAAC,EAAE,MAAM,CAAC;IAC3B;;;;OAIG;IACH,QAAQ,CAAC,IAAI,CAAC,EAAE,OAAO,CAAC;CACzB;AAED;;;;;;GAMG;AACH,MAAM,WAAW,MAAM;IACrB,QAAQ,CAAC,MAAM,EAAE,SAAS,KAAK,EAAE,CAAC;IAClC;;;OAGG;IACH,QAAQ,CAAC,KAAK,CAAC,EAAE,SAAS,MAAM,EAAE,CAAC;CACpC;AAED,mEAAmE;AACnE,MAAM,WAAW,OAAO;IACtB,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAC;IAC1B,kEAAkE;IAClE,QAAQ,CAAC,IAAI,CAAC,EAAE,MAAM,CAAC;IACvB,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC;IACzB;;;OAGG;IACH,QAAQ,CAAC,SAAS,EAAE,SAAS,MAAM,EAAE,CAAC;CACvC;AAED;;;;;;;GAOG;AACH,qBAAa,qBAAsB,SAAQ,KAAK;IAC9C,QAAQ,CAAC,OAAO,EAAE,OAAO,CAAC;gBACd,OAAO,EAAE,OAAO;CAK7B"}

package/dist/permissions/types.js

@@ -0,0 +1,17 @@
+/**
+ * Thrown when a principal runs a mutation they may not.
+ *
+ * An error rather than a silent no-op: enforcement lives at the store, and a
+ * store that quietly did nothing would be indistinguishable from one that
+ * worked. Every caller — a person's click, an agent's tool call, a sync
+ * adapter's inbound change — hits the same wall in the same way.
+ */
+export class PermissionDeniedError extends Error {
+    refusal;
+    constructor(refusal) {
+        super(refusal.message);
+        this.name = "PermissionDeniedError";
+        this.refusal = refusal;
+    }
+}
+//# sourceMappingURL=types.js.map

package/dist/permissions/types.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.js","sourceRoot":"","sources":["../../src/permissions/types.ts"],"names":[],"mappings":"AAsEA;;;;;;;GAOG;AACH,MAAM,OAAO,qBAAsB,SAAQ,KAAK;IACrC,OAAO,CAAU;IAC1B,YAAY,OAAgB;QAC1B,KAAK,CAAC,OAAO,CAAC,OAAO,CAAC,CAAC;QACvB,IAAI,CAAC,IAAI,GAAG,uBAAuB,CAAC;QACpC,IAAI,CAAC,OAAO,GAAG,OAAO,CAAC;IACzB,CAAC;CACF"}

package/dist/persistence/memory.d.ts

@@ -0,0 +1,6 @@
+import type { GraphSnapshot } from "../graph/types.js";
+import type { PersistenceAdapter } from "./types.js";
+/** In-memory adapter. Deep-copies on the way in and out, so a stored graph
+ * cannot be mutated behind the store's back. */
+export declare function createMemoryAdapter(seed?: Record<string, GraphSnapshot>): PersistenceAdapter<string>;
+//# sourceMappingURL=memory.d.ts.map

package/dist/persistence/memory.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"memory.d.ts","sourceRoot":"","sources":["../../src/persistence/memory.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,mBAAmB,CAAC;AAEvD,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,YAAY,CAAC;AAErD;gDACgD;AAChD,wBAAgB,mBAAmB,CACjC,IAAI,GAAE,MAAM,CAAC,MAAM,EAAE,aAAa,CAAM,GACvC,kBAAkB,CAAC,MAAM,CAAC,CA2B5B"}

package/dist/persistence/memory.js

@@ -0,0 +1,31 @@
+/** In-memory adapter. Deep-copies on the way in and out, so a stored graph
+ * cannot be mutated behind the store's back. */
+export function createMemoryAdapter(seed = {}) {
+    const graphs = new Map(Object.entries(seed).map(([k, v]) => [k, clone(v)]));
+    const logs = new Map();
+    return {
+        name: "memory",
+        async load(scope) {
+            const found = graphs.get(scope);
+            return found ? clone(found) : null;
+        },
+        async save(scope, snapshot) {
+            graphs.set(scope, clone(snapshot));
+        },
+        async delete(scope) {
+            graphs.delete(scope);
+            logs.delete(scope);
+        },
+        async loadLog(scope) {
+            return clone(logs.get(scope) ?? []);
+        },
+        async appendOps(scope, ops) {
+            const existing = logs.get(scope) ?? [];
+            logs.set(scope, [...existing, ...clone([...ops])]);
+        },
+    };
+}
+function clone(value) {
+    return structuredClone(value);
+}
+//# sourceMappingURL=memory.js.map

package/dist/persistence/memory.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"memory.js","sourceRoot":"","sources":["../../src/persistence/memory.ts"],"names":[],"mappings":"AAIA;gDACgD;AAChD,MAAM,UAAU,mBAAmB,CACjC,OAAsC,EAAE;IAExC,MAAM,MAAM,GAAG,IAAI,GAAG,CACpB,MAAM,CAAC,OAAO,CAAC,IAAI,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,EAAE,KAAK,CAAC,CAAC,CAAC,CAAC,CAAC,CACpD,CAAC;IACF,MAAM,IAAI,GAAG,IAAI,GAAG,EAAuB,CAAC;IAE5C,OAAO;QACL,IAAI,EAAE,QAAQ;QACd,KAAK,CAAC,IAAI,CAAC,KAAK;YACd,MAAM,KAAK,GAAG,MAAM,CAAC,GAAG,CAAC,KAAK,CAAC,CAAC;YAChC,OAAO,KAAK,CAAC,CAAC,CAAC,KAAK,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,IAAI,CAAC;QACrC,CAAC;QACD,KAAK,CAAC,IAAI,CAAC,KAAK,EAAE,QAAQ;YACxB,MAAM,CAAC,GAAG,CAAC,KAAK,EAAE,KAAK,CAAC,QAAQ,CAAC,CAAC,CAAC;QACrC,CAAC;QACD,KAAK,CAAC,MAAM,CAAC,KAAK;YAChB,MAAM,CAAC,MAAM,CAAC,KAAK,CAAC,CAAC;YACrB,IAAI,CAAC,MAAM,CAAC,KAAK,CAAC,CAAC;QACrB,CAAC;QACD,KAAK,CAAC,OAAO,CAAC,KAAK;YACjB,OAAO,KAAK,CAAC,IAAI,CAAC,GAAG,CAAC,KAAK,CAAC,IAAI,EAAE,CAAC,CAAC;QACtC,CAAC;QACD,KAAK,CAAC,SAAS,CAAC,KAAK,EAAE,GAAG;YACxB,MAAM,QAAQ,GAAG,IAAI,CAAC,GAAG,CAAC,KAAK,CAAC,IAAI,EAAE,CAAC;YACvC,IAAI,CAAC,GAAG,CAAC,KAAK,EAAE,CAAC,GAAG,QAAQ,EAAE,GAAG,KAAK,CAAC,CAAC,GAAG,GAAG,CAAC,CAAC,CAAC,CAAC,CAAC;QACrD,CAAC;KACF,CAAC;AACJ,CAAC;AAED,SAAS,KAAK,CAAI,KAAQ;IACxB,OAAO,eAAe,CAAC,KAAK,CAAC,CAAC;AAChC,CAAC"}