@titan-design/authority 0.0.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Henry Jewkes
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,30 @@
+# @titan-design/authority
+
+The owner-approved authority decision table as data, with its zod schema and a pure
+evaluator. For every action class (merge, release, secret read, spawn, hardware actuation
+and more) and every actor class (owner at a terminal, owner remote, coordinator, worker,
+headless run, automation) the table names exactly one verdict: `allow`, `gate` or `deny`.
+
+Tier 0 of the titan-platform DAG. No titan dependencies, no Node built-ins; `zod` is a peer
+dependency.
+
+```ts
+import { DEFAULT_TABLE, canResolve, evaluate } from "@titan-design/authority";
+
+evaluate(DEFAULT_TABLE, { action: "merge", actor: { class: "worker", id: "w1" }, tainted: false, subject: {} });
+// { verdict: "deny", ruleId: "MRG-WK", reason: "MRG-WK denies merge by worker" }
+
+canResolve(DEFAULT_TABLE, "MRG-CO", { class: "coordinator", tainted: false }); // false
+```
+
+- `evaluate(table, request)`: the decision for one request. No matching rule means deny.
+  A tainted actor on a rule marked `taintEscalates` gets a gate only the owner at a
+  terminal resolves.
+- `canResolve(table, ruleId, resolver)`: false for any agent or automation class and for
+  any tainted resolver.
+- `policyTableSchema`: rejects a table that misses or repeats an action by actor pair, or
+  names anyone but `owner-terminal` or `owner-remote` as a resolver.
+- `DEFAULT_TABLE`: the approved table, also shipped as `@titan-design/authority/table.json`
+  for plain-node hooks.
+
+The library enforces nothing by itself. See the reference page for the full table.

package/dist/index.d.ts

@@ -0,0 +1,107 @@
+import { z } from 'zod';
+
+declare const ACTOR_CLASSES: readonly ["owner-terminal", "owner-remote", "coordinator", "worker", "headless", "automation"];
+/** The only classes that may resolve a gate: the owner, at a terminal or through a verified remote channel. */
+declare const RESOLVER_CLASSES: readonly ["owner-terminal", "owner-remote"];
+declare const ACTION_CLASSES: readonly ["merge", "release", "secret-read", "untrusted-ingest", "private-to-public", "private-egress", "hardware-actuate", "hardware-stop", "destructive-remote", "destructive-local", "destructive-foreign", "spawn", "spend-over-cap", "authority-config", "human-verb"];
+declare const VERDICTS: readonly ["allow", "gate", "deny"];
+/** Codes for the record each rule expects to leave behind, from a decision record to a device read-back. */
+declare const EVIDENCE_KINDS: readonly ["E-dec", "E-gate", "E-ref", "E-byp", "E-gh", "E-npm", "E-spn", "E-prin", "E-dev"];
+type ActorClass = (typeof ACTOR_CLASSES)[number];
+type ResolverClass = (typeof RESOLVER_CLASSES)[number];
+type ActionClass = (typeof ACTION_CLASSES)[number];
+type Verdict = (typeof VERDICTS)[number];
+type EvidenceKind = (typeof EVIDENCE_KINDS)[number];
+
+declare const ruleSchema: z.ZodObject<{
+    id: z.ZodString;
+    action: z.ZodEnum<{
+        merge: "merge";
+        release: "release";
+        "secret-read": "secret-read";
+        "untrusted-ingest": "untrusted-ingest";
+        "private-to-public": "private-to-public";
+        "private-egress": "private-egress";
+        "hardware-actuate": "hardware-actuate";
+        "hardware-stop": "hardware-stop";
+        "destructive-remote": "destructive-remote";
+        "destructive-local": "destructive-local";
+        "destructive-foreign": "destructive-foreign";
+        spawn: "spawn";
+        "spend-over-cap": "spend-over-cap";
+        "authority-config": "authority-config";
+        "human-verb": "human-verb";
+    }>;
+    actor: z.ZodEnum<{
+        "owner-terminal": "owner-terminal";
+        "owner-remote": "owner-remote";
+        coordinator: "coordinator";
+        worker: "worker";
+        headless: "headless";
+        automation: "automation";
+    }>;
+    verdict: z.ZodEnum<{
+        allow: "allow";
+        gate: "gate";
+        deny: "deny";
+    }>;
+    resolvers: z.ZodOptional<z.ZodArray<z.ZodEnum<{
+        "owner-terminal": "owner-terminal";
+        "owner-remote": "owner-remote";
+    }>>>;
+    taintEscalates: z.ZodOptional<z.ZodBoolean>;
+    condition: z.ZodOptional<z.ZodString>;
+    evidence: z.ZodArray<z.ZodEnum<{
+        "E-dec": "E-dec";
+        "E-gate": "E-gate";
+        "E-ref": "E-ref";
+        "E-byp": "E-byp";
+        "E-gh": "E-gh";
+        "E-npm": "E-npm";
+        "E-spn": "E-spn";
+        "E-prin": "E-prin";
+        "E-dev": "E-dev";
+    }>>;
+}, z.core.$strip>;
+type Rule = z.infer<typeof ruleSchema>;
+interface PolicyTable {
+    version: string;
+    rules: Rule[];
+}
+/** Validates a table: every (action, actor) pair exactly once, and only owner classes as gate resolvers. */
+declare const policyTableSchema: z.ZodType<PolicyTable>;
+
+interface AuthorityRequest {
+    action: ActionClass;
+    actor: {
+        class: ActorClass;
+        id: string;
+    };
+    tainted: boolean;
+    subject: Record<string, string>;
+}
+type Decision = {
+    verdict: "allow";
+    ruleId: string;
+} | {
+    verdict: "gate";
+    ruleId: string;
+    resolvers: ResolverClass[];
+    reason: string;
+} | {
+    verdict: "deny";
+    ruleId: string | null;
+    reason: string;
+};
+/** Decides one request against a table. Pure: no clock, no environment, and no match means deny. */
+declare function evaluate(table: PolicyTable, request: AuthorityRequest): Decision;
+/** Whether a resolver may resolve the gate a rule opens. Agents, automation and tainted sessions never may. */
+declare function canResolve(table: PolicyTable, ruleId: string, resolver: {
+    class: ActorClass;
+    tainted: boolean;
+}): boolean;
+
+/** The owner-approved decision table, validated on load. The same data ships as `@titan-design/authority/table.json`. */
+declare const DEFAULT_TABLE: PolicyTable;
+
+export { ACTION_CLASSES, ACTOR_CLASSES, type ActionClass, type ActorClass, type AuthorityRequest, DEFAULT_TABLE, type Decision, EVIDENCE_KINDS, type EvidenceKind, type PolicyTable, RESOLVER_CLASSES, type ResolverClass, type Rule, VERDICTS, type Verdict, canResolve, evaluate, policyTableSchema };