@punica/editor 1.43.0 → 1.45.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@punica/editor",
-  "version": "1.43.0",
+  "version": "1.45.0",
   "description": "Punica Editor",
   "private": false,
   "type": "module",

package/types/punica.module.kernel.ai.d.ts

@@ -78,6 +78,26 @@ declare module 'punica' {
          * asks the right one. Absent means the file named none.
          */
         org?: string;
+        /**
+         * How many of them must sign (`kernel.PolicyRequest.signatures`),
+         * when more than one. A card then says how many have, and offers
+         * a signature rather than a grant.
+         */
+        signatures?: number;
+        /**
+         * Who has signed so far, under which name — the record's own
+         * list, copied onto the question by `approvePending` when a
+         * signature lands and the chain is still short. A person on it
+         * cannot sign again.
+         */
+        signed?: ReadonlyArray<{ by: string; role?: string; atMs: number }>;
+        /**
+         * The scope the first signature was recorded at. The next ones are
+         * recorded at the same scope, whatever the card offered: a grant
+         * is one record, and two signatures at two scopes would be two
+         * half-signed records.
+         */
+        signedScope?: ApprovalScope;
         /**
          * Set by `referPending`: the question was handed to a reviewer
          * outside this host, under this name. A run waiting on it holds

package/types/punica.module.kernel.policy.d.ts

@@ -38,6 +38,16 @@ declare module 'punica' {
        * remote` reaches exactly the requests that carry this.
        */
       egress?: 'remote';
+      /**
+       * `'declared'` when the capability classifies itself or this call's
+       * input as sensitive (`dataClassification: 'sensitive'`, or a value
+       * at a schema path annotated `sensitive: true`), `'taint'` when a
+       * call earlier in the same trace read something declared sensitive
+       * and completed — as `egressGuard` resolved it. A rule with
+       * `sensitive: true` reaches exactly the requests that carry this
+       * (`docs/sensitive-data-egress.md` T2, T3).
+       */
+      sensitive?: 'declared' | 'taint';
       risk: PolicyRisk;
       approval: PolicyApproval;
       /**
@@ -85,6 +95,13 @@ declare module 'punica' {
        * role in any of the person's organisations counts.
        */
       org?: string;
+      /**
+       * How many of those approvers must sign before the grant stands
+       * (the deciding rule's `signatures:`). Absent or `1` is one
+       * decision; `2` means two different people, each one an entry
+       * names, and a record with fewer is consulted as no grant at all.
+       */
+      signatures?: number;
     }
 
     /**
@@ -130,6 +147,12 @@ declare module 'punica' {
       timestampMs: number;
       /** Optional reason — surfaced in audit. */
       reason?: string;
+      /**
+       * Under which of the rule's names this person signed (`owner`,
+       * `role:<name>`, `user:<email>`) — a `signatures` chain records it
+       * per signer, the way a single grant records `decidedRole`.
+       */
+      role?: string;
     }
 
     /** Chain-level outcome of `recordChainDecision`. */
@@ -154,6 +177,19 @@ declare module 'punica' {
       | {
           type: 'single';
           approver: ApproverSpec;
+        }
+      | {
+          /**
+           * A rule's `signatures: N` (1.44.0): `required` different
+           * people, each one of the rule's `approvers` entries, in any
+           * order; any deny ends it. The people are not known when the
+           * chain opens — a role names a set — so `approverId` is the
+           * signer's address and the spec lists the rule's entries, not
+           * ids. The policy manager is this shape's caller.
+           */
+          type: 'signatures';
+          required: number;
+          approvers: readonly string[];
         };
 
     /** Snapshot of a running chain — read-only from the caller's POV. */
@@ -192,6 +228,17 @@ declare module 'punica' {
        * record + chain state by this id.
        */
       chainRef?: string;
+      /**
+       * The signatures a `signatures: N` rule collected on this record
+       * (1.44.0): how many it needs and who signed, under which name. A
+       * record with fewer signatures than `need` is stored — so the next
+       * signer finds it and a reader sees who is missing — and is never
+       * consulted as a grant. Absent on a single-decision grant.
+       */
+      signatures?: {
+        need: number;
+        by: ReadonlyArray<{ by: string; role?: string; atMs: number }>;
+      };
       /**
        * The arguments this grant covers. See `PolicyRequest.argsBinding`.
        * Persisted so a grant matches only the arguments it was given
@@ -232,6 +279,8 @@ declare module 'punica' {
       approvers?: readonly string[];
       /** The organisation those approvers hold their roles in (the file's `org:`). */
       org?: string;
+      /** How many of them must sign (the rule's `signatures:`), when more than one. */
+      signatures?: number;
       reason?: string;
       /**
        * Set when a rule from a policy template decided this. Absent
@@ -524,6 +573,14 @@ declare module 'punica' {
        * (`docs/sensitive-data-egress.md`). The only value is `remote`.
        */
       egress?: 'remote';
+      /**
+       * Selects the calls that carry sensitive material — by the
+       * capability's declaration or by the run's taint, as the gate
+       * resolved it. The only value is `true`; written beside `egress:
+       * remote`, `deny` is the sentence "sensitive data does not leave this
+       * machine" while other remote calls still may.
+       */
+      sensitive?: true;
       effect: PolicyRuleEffect;
       /** ANDed. Absent or empty matches every argument tuple. */
       when?: PolicyCondition[];
@@ -549,6 +606,14 @@ declare module 'punica' {
        * which is what every rule written before this field meant.
        */
       approvers?: string[];
+      /**
+       * How many of those approvers must sign, only with `approvers:` on
+       * `effect: 'require'`. `2` is two different people, each one an
+       * entry names, in any order; one person cannot sign twice, and a
+       * signer needs a name. Absent or `1` is one decision, which is
+       * what every rule written before this field meant.
+       */
+      signatures?: number;
       /** Shown to the user on a denial and written into the audit record. */
       reason?: string;
     }
@@ -567,6 +632,10 @@ declare module 'punica' {
       approvers?: string[];
       /** The file's `org:`, when it wrote one — where those approvers hold their roles. */
       org?: string;
+      /** The rule's `signatures`, when more than one. */
+      signatures?: number;
+      /** The rule's `sensitive: true`, when it wrote it. */
+      sensitive?: true;
       /** Digest of the template's rules — which policy text was in force. */
       digest?: string;
       /**
@@ -574,7 +643,7 @@ declare module 'punica' {
        * declares. A reader of the audit record can otherwise not tell
        * why a rule naming no id applied to this call.
        */
-      matchedBy?: 'id' | 'action' | 'egress';
+      matchedBy?: 'id' | 'action' | 'egress' | 'sensitive';
     }
 
     /** A rule that matched, plus the rule itself for the caller to read. */