@suveren/gateway 0.8.7 → 0.10.0

package/dist/ui/index.html

@@ -14,7 +14,7 @@
     <meta name="apple-mobile-web-app-title" content="Suveren" />
     <meta name="theme-color" content="#111111" />
     <title>Suveren</title>
-    <script type="module" crossorigin src="/assets/index-tzStUGuj.js"></script>
+    <script type="module" crossorigin src="/assets/index-B1qNl7zo.js"></script>
     <link rel="stylesheet" crossorigin href="/assets/index-BJqF5rmx.css">
   </head>
   <body>

package/lib/as-pairing.mjs

@@ -0,0 +1,77 @@
+/**
+ * Minimal reader/writer for `<dataDir>/as-pairing.json` — the CLI's copy.
+ *
+ * Mirrors `apps/control-plane/src/lib/as-pairing.ts` (same file shape, same
+ * rules) but written in plain JS, same reason as `config.mjs`: this runs as
+ * `bundle/bin/suveren-gateway.js`, hand-authored ESM shipped as-is. Only
+ * what the CLI's `config set pin-tls on --expect-fingerprint` /
+ * `start --pin-tls --expect-fingerprint` need is implemented here —
+ * `readPairing` and `recordTlsPin`. Keep in step with the TS version if the
+ * file shape changes.
+ */
+import { existsSync, readFileSync, writeFileSync } from 'node:fs';
+import { join } from 'node:path';
+
+function pairingPath(dataDir) {
+  return join(dataDir, 'as-pairing.json');
+}
+
+export function readPairing(dataDir) {
+  const path = pairingPath(dataDir);
+  if (!existsSync(path)) return null;
+  try {
+    const data = JSON.parse(readFileSync(path, 'utf8'));
+    if (typeof data.asUrl !== 'string' || typeof data.publicKeyHex !== 'string') return null;
+    return {
+      asUrl: data.asUrl,
+      publicKeyHex: data.publicKeyHex,
+      pairedAt: data.pairedAt ?? '',
+      ...(typeof data.tlsSpkiPinHex === 'string' ? { tlsSpkiPinHex: data.tlsSpkiPinHex } : {}),
+    };
+  } catch {
+    return null;
+  }
+}
+
+/** Attach/overwrite the TLS SPKI pin on the EXISTING pairing record for
+ *  `asUrl`. Returns false (no-op) when there is no existing pairing for
+ *  this URL to attach to — the CLI falls back to the config.json
+ *  `pinTlsExpectedFingerprint` staging field in that case (see
+ *  suveren-gateway.js), since a pairing record requires a `publicKeyHex`
+ *  this command never has. */
+export function recordTlsPin(dataDir, asUrl, tlsSpkiPinHex) {
+  const existing = readPairing(dataDir);
+  if (!existing || existing.asUrl !== asUrl) return false;
+  const path = pairingPath(dataDir);
+  writeFileSync(
+    path,
+    JSON.stringify({ ...existing, tlsSpkiPinHex }, null, 2),
+    { encoding: 'utf8', mode: 0o600 },
+  );
+  return true;
+}
+
+/** Group a hex digest into colon-separated uppercase quads — the
+ *  human-readable, compare-over-the-phone form. Same convention as
+ *  as-pairing.ts's `fingerprintOf` / as-tls-pin.ts's `formatPinFingerprint`,
+ *  applied here to an already-computed digest (never re-hashes anything). */
+export function formatFingerprint(hex) {
+  const upper = hex.toUpperCase();
+  return upper.match(/.{1,4}/g)?.join(':') ?? upper;
+}
+
+/**
+ * Validate + normalize a candidate SHA-256 fingerprint: accepts with or
+ * without colons/spaces/grouping, case-insensitive. Returns
+ * `{ ok: true, hex }` (lowercase, no separators) or `{ ok: false, error }`.
+ */
+export function normalizeFingerprint(raw) {
+  const hex = (raw ?? '').replace(/[^0-9a-fA-F]/g, '').toLowerCase();
+  if (!/^[0-9a-f]{64}$/.test(hex)) {
+    return {
+      ok: false,
+      error: 'must be a 64-character SHA-256 hex digest (colons/spacing are fine), e.g. the output of `openssl dgst -sha256`.',
+    };
+  }
+  return { ok: true, hex };
+}

package/lib/config.d.mts

@@ -0,0 +1,37 @@
+/**
+ * Types for the plain-ESM saved-config module.
+ *
+ * The module is .mjs because the CLI (plain JS, no build step) imports it
+ * directly. TypeScript consumers — the tests — need declarations, and without
+ * them a typecheck fails with TS7016 rather than checking anything (see
+ * autostart-templates.d.mts for the established precedent).
+ */
+
+export declare const DEFAULT_AS_URL: string;
+
+export interface SavedConfig {
+  asUrl?: string;
+  caFile?: string;
+}
+
+export declare function readConfig(dataDir: string): SavedConfig;
+export declare function writeConfig(dataDir: string, patch: SavedConfig): SavedConfig;
+
+export interface AsUrlValidation {
+  ok: boolean;
+  url?: string;
+  error?: string;
+}
+
+export declare function validateAsUrl(candidate: string): AsUrlValidation;
+
+export interface CaFileValidation {
+  ok: boolean;
+  path?: string;
+  error?: string;
+}
+
+export declare function validateCaFile(candidate: string): CaFileValidation;
+
+export declare function resolveAsUrl(dataDir: string): string;
+export declare function resolveCaFile(dataDir: string): string | undefined;

package/lib/config.mjs

@@ -0,0 +1,198 @@
+/**
+ * Saved gateway config (`<dataDir>/config.json`) — the CLI's copy.
+ *
+ * Mirrors `apps/mcp-server/src/lib/as-config.ts` / `apps/control-plane/src/lib/as-config.ts`
+ * (same file shape, same validation rules) but written in plain JS: this
+ * runs as bundle/bin/suveren-gateway.js and bundle/server.js, which are
+ * hand-authored ESM shipped as-is (not built by tsup like the apps), so
+ * there is no shared runtime package to import the TS version from. Keep
+ * all three in step if the shape or validation rules change.
+ *
+ * Not secret — an Authority Server URL and a CA file path are not
+ * credentials — so this is plain JSON, same trust level as the rest of
+ * config.json.
+ */
+
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from 'node:fs';
+import { dirname, join, resolve } from 'node:path';
+
+export const DEFAULT_AS_URL = 'https://www.suveren.ai';
+
+function configPath(dataDir) {
+  return join(dataDir, 'config.json');
+}
+
+/** Tolerant of a missing or corrupt file — both degrade to "{}", never throw. */
+export function readConfig(dataDir) {
+  const path = configPath(dataDir);
+  if (!existsSync(path)) return {};
+  try {
+    const data = JSON.parse(readFileSync(path, 'utf8'));
+    const out = {};
+    if (typeof data.asUrl === 'string') out.asUrl = data.asUrl;
+    if (typeof data.caFile === 'string') out.caFile = data.caFile;
+    if (typeof data.pinTls === 'boolean') out.pinTls = data.pinTls;
+    if (typeof data.pinTlsExpectedFingerprint === 'string') out.pinTlsExpectedFingerprint = data.pinTlsExpectedFingerprint;
+    return out;
+  } catch {
+    return {};
+  }
+}
+
+/**
+ * Strict counterpart used only by resolveAsUrl: distinguishes "genuinely
+ * absent" (fine — falls through to the default) from "present but
+ * unparsable" (must refuse to start, not silently behave like an empty
+ * file — see resolveAsUrl's doc comment).
+ */
+function readConfigStrict(dataDir) {
+  const path = configPath(dataDir);
+  if (!existsSync(path)) return {};
+  let data;
+  try {
+    data = JSON.parse(readFileSync(path, 'utf8'));
+  } catch (err) {
+    throw new Error(`Could not parse ${path}: ${err instanceof Error ? err.message : String(err)}`);
+  }
+  const out = {};
+  if (typeof data.asUrl === 'string') out.asUrl = data.asUrl;
+  if (typeof data.caFile === 'string') out.caFile = data.caFile;
+  if (typeof data.pinTls === 'boolean') out.pinTls = data.pinTls;
+  if (typeof data.pinTlsExpectedFingerprint === 'string') out.pinTlsExpectedFingerprint = data.pinTlsExpectedFingerprint;
+  return out;
+}
+
+export function writeConfig(dataDir, patch) {
+  const merged = { ...readConfig(dataDir), ...patch };
+  const path = configPath(dataDir);
+  mkdirSync(dirname(path), { recursive: true, mode: 0o700 });
+  writeFileSync(path, JSON.stringify(merged, null, 2), { encoding: 'utf8', mode: 0o600 });
+  return merged;
+}
+
+/**
+ * Validate + normalize a candidate Authority Server URL.
+ * https only, except http://localhost / http://127.0.0.1; trailing slash
+ * stripped rather than rejected. Returns `{ ok, url }` or `{ ok: false, error }`.
+ */
+export function validateAsUrl(candidate) {
+  const trimmed = (candidate ?? '').trim();
+  if (!trimmed) return { ok: false, error: 'The Authority Server URL is empty.' };
+
+  let parsed;
+  try {
+    parsed = new URL(trimmed);
+  } catch {
+    return { ok: false, error: `"${trimmed}" is not a valid URL.` };
+  }
+
+  const isLocalHttp =
+    parsed.protocol === 'http:' && (parsed.hostname === 'localhost' || parsed.hostname === '127.0.0.1');
+  if (parsed.protocol !== 'https:' && !isLocalHttp) {
+    return {
+      ok: false,
+      error: `"${trimmed}" must use https:// (http:// is only allowed for http://localhost or http://127.0.0.1).`,
+    };
+  }
+
+  let normalized = `${parsed.origin}${parsed.pathname}${parsed.search}${parsed.hash}`;
+  if (normalized.endsWith('/') && normalized !== `${parsed.origin}/`) {
+    normalized = normalized.slice(0, -1);
+  } else if (normalized === `${parsed.origin}/`) {
+    normalized = parsed.origin;
+  }
+
+  return { ok: true, url: normalized };
+}
+
+/**
+ * Validate a candidate CA file path: must exist and be readable. Returns an
+ * ABSOLUTE path (resolved against the CURRENT working directory) — a
+ * relative one saved as-is would resolve differently depending on where a
+ * later `start`/autostart happens to run from (a login service's cwd is
+ * rarely the directory someone typed the flag from). Does not check that it
+ * PARSES as PEM — Node reports that itself, loudly, at TLS handshake time if
+ * it's wrong, which is soon enough for a rare setup step.
+ */
+export function validateCaFile(candidate) {
+  const trimmed = (candidate ?? '').trim();
+  if (!trimmed) return { ok: false, error: 'The CA file path is empty.' };
+  const absolute = resolve(process.cwd(), trimmed);
+  if (!existsSync(absolute)) return { ok: false, error: `No file at "${absolute}".` };
+  return { ok: true, path: absolute };
+}
+
+/**
+ * Resolution order: env SUVEREN_AS_URL > saved config > default. Throws on
+ * an explicitly-set-but-invalid env var, AND on a saved value that is
+ * present but invalid or on a config.json that won't parse — fail closed,
+ * audibly. For a self-hosted customer, silently falling back to the public
+ * default here would mean their real API key gets sent to suveren.ai instead
+ * of their own server. Only a genuinely ABSENT saved value (nothing was ever
+ * set) falls through to the default.
+ */
+export function resolveAsUrl(dataDir) {
+  const envUrl = process.env.SUVEREN_AS_URL;
+  if (envUrl) {
+    const v = validateAsUrl(envUrl);
+    if (!v.ok) throw new Error(`Invalid SUVEREN_AS_URL: ${v.error}`);
+    return v.url;
+  }
+  const saved = readConfigStrict(dataDir).asUrl;
+  if (saved) {
+    const v = validateAsUrl(saved);
+    if (!v.ok) throw new Error(`Invalid saved as-url "${saved}" in ${dataDir}/config.json: ${v.error}`);
+    return v.url;
+  }
+  return DEFAULT_AS_URL;
+}
+
+/** The saved CA file path, if any — no env/flag tier (see bundle/server.js,
+ *  the one place that reads and acts on it). */
+export function resolveCaFile(dataDir) {
+  return readConfig(dataDir).caFile;
+}
+
+/**
+ * Validate a candidate --pin-tls value against the EFFECTIVE Authority
+ * Server URL: TLS pinning on an http:// AS (only ever localhost/127.0.0.1 —
+ * see validateAsUrl) has nothing to pin, so enabling it there is refused
+ * rather than silently accepted and then doing nothing.
+ */
+export function validatePinTls(effectiveAsUrl) {
+  let parsed;
+  try {
+    parsed = new URL(effectiveAsUrl);
+  } catch {
+    return { ok: false, error: `"${effectiveAsUrl}" is not a valid URL.` };
+  }
+  if (parsed.protocol !== 'https:') {
+    return {
+      ok: false,
+      error: `--pin-tls requires an https:// Authority Server URL (currently "${effectiveAsUrl}") — there is no TLS certificate to pin.`,
+    };
+  }
+  return { ok: true };
+}
+
+/** The saved pin-tls setting. No env/flag tier — only ever set through
+ *  `--pin-tls` / `config set pin-tls on|off`. Default false: opt-in,
+ *  never silently on. */
+export function resolvePinTls(dataDir) {
+  return readConfig(dataDir).pinTls === true;
+}
+
+/**
+ * A fingerprint confirmed via `--expect-fingerprint` BEFORE any signing-key
+ * pairing exists yet (so there is no as-pairing.json to attach a TLS pin
+ * to — see as-pairing.mjs's `recordTlsPin`, which needs an existing record).
+ * Staged here until the first verified sign-in challenge: that challenge
+ * MUST match this value (enforced exactly like an already-stored pin — see
+ * the control plane's checkAsKeyBeforeLogin), and once it does, the value
+ * moves into as-pairing.json and this staging field is cleared. Absent in
+ * every other case — once a real pairing with a TLS pin exists, that record
+ * is authoritative and this is never consulted again.
+ */
+export function resolvePinTlsExpectedFingerprint(dataDir) {
+  return readConfig(dataDir).pinTlsExpectedFingerprint;
+}

package/node_modules/@hap/core/dist/index.d.mts

@@ -610,7 +610,21 @@ interface ExecutionLogQuery {
      * Sum a field's values within a time window for a given profile.
      * Use field="_count" to count executions instead of summing a field.
      */
-    sumByWindow(profileId: string, path: string, field: string, window: CumulativeWindow, now?: number): number;
+    sumByWindow(profileId: string, path: string, field: string, window: CumulativeWindow, now?: number, 
+    /**
+     * Only count executions whose `execution.action_type` is one of these.
+     * Omitted → every execution counts (a bound that governs all action types).
+     *
+     * Consumption is partitioned by action type (*Cumulative Tracking* rule 4):
+     * a bound counts only the action types it governs. Without the filter a
+     * profile with several action types feeds every bound the combined total —
+     * sales' "orders per day" counted quotes and sends too, and its daily order
+     * value summed quote values. Use {@link boundActionTypes} to derive it.
+     *
+     * Implementations SHOULD count an entry that carries no `action_type`
+     * against every filter: an unknown action is not evidence of headroom.
+     */
+    actionTypes?: readonly string[]): number;
 }
 /**
  * Agent frame parameters — mixed types (strings and numbers).
@@ -1126,6 +1140,23 @@ declare function verifyAttestationV4(blob: string, publicKeyHex: string, expecte
  * @param executionLog - Optional execution log for resolving cumulative fields
  */
 declare function verify(request: GatekeeperRequest, publicKeyHex: string, now?: number, executionLog?: ExecutionLogQuery): Promise<GatekeeperResult>;
+/**
+ * Which action types' executions count toward this cumulative bound's running
+ * total. `undefined` means all of them.
+ *
+ * `boundGovernsAction` decides whether a bound applies to the current call; this
+ * decides what the bound's total is made of. Both are needed: selecting the right
+ * bound and then feeding it the profile's combined total is still wrong — sales'
+ * "orders per day" was checked only on orders, but counted every quote and send.
+ * Consumption is partitioned by action type (*Cumulative Tracking* rule 4), as
+ * the Authority Server already does.
+ *
+ * Same answer, same order of preference as `boundGovernsAction`: the declared
+ * `appliesTo`; else, for a count bound named for an action (`delete_daily_max`),
+ * that action; else every action type. Exported so display surfaces report the
+ * same totals the gate enforces.
+ */
+declare function boundActionTypes(fieldName: string, fieldDef: ProfileBoundsField): readonly string[] | undefined;
 
 /**
  * Profile Registry — dynamically populated from git-hosted profile sources.
@@ -1322,4 +1353,4 @@ interface ReceiptPayload {
  */
 declare function verifyReceiptSignature(receipt: ReceiptPayload, publicKeyHex: string): Promise<void>;
 
-export { type AgentBoundsParams, type AgentContextParams, type AgentFrameParams, type AgentProfile, type ApprovalObject, type Attestation, type AttestationHeader, type AttestationPayload, type BoundType, CanonicalValueError, type ContentBinding, ContentBindingError, type ContentBindingErrorCode, type CumulativeFieldDef, type CumulativeWindow, type DeclaredFieldDef, type ExecutionContextFieldDef, type ExecutionLogEntry, type ExecutionLogQuery, type ExecutionMappingTransform, type ExecutionMappingValue, type ExecutionPath, type FieldConstraint, type FieldUnit, type GateQuestion, type GatekeeperError, type GatekeeperRequest, type GatekeeperResult, type MandateBinding, MandateError, type MandateProjection, type OwnerMandate, type ProfileBoundsField, type ProfileContextField, type ProfileFrameField, type ProfileToolGating, type ProfileToolGatingEntry, type ReceiptPayload, type ResolvedDomain, type SigningSurface, type Subject, type SubjectValidation, approvalSigningBytes, attestationId, bindingAppliesTo, buildMandateProjection, canonicalBounds, canonicalContext, canonicalFrame, canonicalize, canonicalizeText, checkAttestationExpiry, clearProfiles, computeBoundsHash, computeContentHash, computeContextHash, computeFieldsContentHash, computeFrameHash, computeIntentDisclosureHash, computeIntentHash, contentCanonicalBytes, decodeAttestationBlob, decodeDidKey, deriveIdentityLine, encodeAttestationBlob, encodeDidKey, frameHash, getAllProfiles, getProfile, intentDisclosureCanonicalBytes, isFieldBinding, isKeyBearingDid, isV4Attestation, listProfiles, mandateSigningBytes, registerProfile, selectBoundFields, signApproval, signMandateProjection, validateBoundsParams, validateContextParams, validateFrameParams, validateSubject, verify, verifyApproval, verifyAttestation, verifyAttestationSignature, verifyAttestationV4, verifyBoundsHash, verifyContextHash, verifyFrameHash, verifyOwnerMandate, verifyOwnerMandates, verifyReceiptSignature };
+export { type AgentBoundsParams, type AgentContextParams, type AgentFrameParams, type AgentProfile, type ApprovalObject, type Attestation, type AttestationHeader, type AttestationPayload, type BoundType, CanonicalValueError, type ContentBinding, ContentBindingError, type ContentBindingErrorCode, type CumulativeFieldDef, type CumulativeWindow, type DeclaredFieldDef, type ExecutionContextFieldDef, type ExecutionLogEntry, type ExecutionLogQuery, type ExecutionMappingTransform, type ExecutionMappingValue, type ExecutionPath, type FieldConstraint, type FieldUnit, type GateQuestion, type GatekeeperError, type GatekeeperRequest, type GatekeeperResult, type MandateBinding, MandateError, type MandateProjection, type OwnerMandate, type ProfileBoundsField, type ProfileContextField, type ProfileFrameField, type ProfileToolGating, type ProfileToolGatingEntry, type ReceiptPayload, type ResolvedDomain, type SigningSurface, type Subject, type SubjectValidation, approvalSigningBytes, attestationId, bindingAppliesTo, boundActionTypes, buildMandateProjection, canonicalBounds, canonicalContext, canonicalFrame, canonicalize, canonicalizeText, checkAttestationExpiry, clearProfiles, computeBoundsHash, computeContentHash, computeContextHash, computeFieldsContentHash, computeFrameHash, computeIntentDisclosureHash, computeIntentHash, contentCanonicalBytes, decodeAttestationBlob, decodeDidKey, deriveIdentityLine, encodeAttestationBlob, encodeDidKey, frameHash, getAllProfiles, getProfile, intentDisclosureCanonicalBytes, isFieldBinding, isKeyBearingDid, isV4Attestation, listProfiles, mandateSigningBytes, registerProfile, selectBoundFields, signApproval, signMandateProjection, validateBoundsParams, validateContextParams, validateFrameParams, validateSubject, verify, verifyApproval, verifyAttestation, verifyAttestationSignature, verifyAttestationV4, verifyBoundsHash, verifyContextHash, verifyFrameHash, verifyOwnerMandate, verifyOwnerMandates, verifyReceiptSignature };

package/node_modules/@hap/core/dist/index.d.ts

@@ -610,7 +610,21 @@ interface ExecutionLogQuery {
      * Sum a field's values within a time window for a given profile.
      * Use field="_count" to count executions instead of summing a field.
      */
-    sumByWindow(profileId: string, path: string, field: string, window: CumulativeWindow, now?: number): number;
+    sumByWindow(profileId: string, path: string, field: string, window: CumulativeWindow, now?: number, 
+    /**
+     * Only count executions whose `execution.action_type` is one of these.
+     * Omitted → every execution counts (a bound that governs all action types).
+     *
+     * Consumption is partitioned by action type (*Cumulative Tracking* rule 4):
+     * a bound counts only the action types it governs. Without the filter a
+     * profile with several action types feeds every bound the combined total —
+     * sales' "orders per day" counted quotes and sends too, and its daily order
+     * value summed quote values. Use {@link boundActionTypes} to derive it.
+     *
+     * Implementations SHOULD count an entry that carries no `action_type`
+     * against every filter: an unknown action is not evidence of headroom.
+     */
+    actionTypes?: readonly string[]): number;
 }
 /**
  * Agent frame parameters — mixed types (strings and numbers).
@@ -1126,6 +1140,23 @@ declare function verifyAttestationV4(blob: string, publicKeyHex: string, expecte
  * @param executionLog - Optional execution log for resolving cumulative fields
  */
 declare function verify(request: GatekeeperRequest, publicKeyHex: string, now?: number, executionLog?: ExecutionLogQuery): Promise<GatekeeperResult>;
+/**
+ * Which action types' executions count toward this cumulative bound's running
+ * total. `undefined` means all of them.
+ *
+ * `boundGovernsAction` decides whether a bound applies to the current call; this
+ * decides what the bound's total is made of. Both are needed: selecting the right
+ * bound and then feeding it the profile's combined total is still wrong — sales'
+ * "orders per day" was checked only on orders, but counted every quote and send.
+ * Consumption is partitioned by action type (*Cumulative Tracking* rule 4), as
+ * the Authority Server already does.
+ *
+ * Same answer, same order of preference as `boundGovernsAction`: the declared
+ * `appliesTo`; else, for a count bound named for an action (`delete_daily_max`),
+ * that action; else every action type. Exported so display surfaces report the
+ * same totals the gate enforces.
+ */
+declare function boundActionTypes(fieldName: string, fieldDef: ProfileBoundsField): readonly string[] | undefined;
 
 /**
  * Profile Registry — dynamically populated from git-hosted profile sources.
@@ -1322,4 +1353,4 @@ interface ReceiptPayload {
  */
 declare function verifyReceiptSignature(receipt: ReceiptPayload, publicKeyHex: string): Promise<void>;
 
-export { type AgentBoundsParams, type AgentContextParams, type AgentFrameParams, type AgentProfile, type ApprovalObject, type Attestation, type AttestationHeader, type AttestationPayload, type BoundType, CanonicalValueError, type ContentBinding, ContentBindingError, type ContentBindingErrorCode, type CumulativeFieldDef, type CumulativeWindow, type DeclaredFieldDef, type ExecutionContextFieldDef, type ExecutionLogEntry, type ExecutionLogQuery, type ExecutionMappingTransform, type ExecutionMappingValue, type ExecutionPath, type FieldConstraint, type FieldUnit, type GateQuestion, type GatekeeperError, type GatekeeperRequest, type GatekeeperResult, type MandateBinding, MandateError, type MandateProjection, type OwnerMandate, type ProfileBoundsField, type ProfileContextField, type ProfileFrameField, type ProfileToolGating, type ProfileToolGatingEntry, type ReceiptPayload, type ResolvedDomain, type SigningSurface, type Subject, type SubjectValidation, approvalSigningBytes, attestationId, bindingAppliesTo, buildMandateProjection, canonicalBounds, canonicalContext, canonicalFrame, canonicalize, canonicalizeText, checkAttestationExpiry, clearProfiles, computeBoundsHash, computeContentHash, computeContextHash, computeFieldsContentHash, computeFrameHash, computeIntentDisclosureHash, computeIntentHash, contentCanonicalBytes, decodeAttestationBlob, decodeDidKey, deriveIdentityLine, encodeAttestationBlob, encodeDidKey, frameHash, getAllProfiles, getProfile, intentDisclosureCanonicalBytes, isFieldBinding, isKeyBearingDid, isV4Attestation, listProfiles, mandateSigningBytes, registerProfile, selectBoundFields, signApproval, signMandateProjection, validateBoundsParams, validateContextParams, validateFrameParams, validateSubject, verify, verifyApproval, verifyAttestation, verifyAttestationSignature, verifyAttestationV4, verifyBoundsHash, verifyContextHash, verifyFrameHash, verifyOwnerMandate, verifyOwnerMandates, verifyReceiptSignature };
+export { type AgentBoundsParams, type AgentContextParams, type AgentFrameParams, type AgentProfile, type ApprovalObject, type Attestation, type AttestationHeader, type AttestationPayload, type BoundType, CanonicalValueError, type ContentBinding, ContentBindingError, type ContentBindingErrorCode, type CumulativeFieldDef, type CumulativeWindow, type DeclaredFieldDef, type ExecutionContextFieldDef, type ExecutionLogEntry, type ExecutionLogQuery, type ExecutionMappingTransform, type ExecutionMappingValue, type ExecutionPath, type FieldConstraint, type FieldUnit, type GateQuestion, type GatekeeperError, type GatekeeperRequest, type GatekeeperResult, type MandateBinding, MandateError, type MandateProjection, type OwnerMandate, type ProfileBoundsField, type ProfileContextField, type ProfileFrameField, type ProfileToolGating, type ProfileToolGatingEntry, type ReceiptPayload, type ResolvedDomain, type SigningSurface, type Subject, type SubjectValidation, approvalSigningBytes, attestationId, bindingAppliesTo, boundActionTypes, buildMandateProjection, canonicalBounds, canonicalContext, canonicalFrame, canonicalize, canonicalizeText, checkAttestationExpiry, clearProfiles, computeBoundsHash, computeContentHash, computeContextHash, computeFieldsContentHash, computeFrameHash, computeIntentDisclosureHash, computeIntentHash, contentCanonicalBytes, decodeAttestationBlob, decodeDidKey, deriveIdentityLine, encodeAttestationBlob, encodeDidKey, frameHash, getAllProfiles, getProfile, intentDisclosureCanonicalBytes, isFieldBinding, isKeyBearingDid, isV4Attestation, listProfiles, mandateSigningBytes, registerProfile, selectBoundFields, signApproval, signMandateProjection, validateBoundsParams, validateContextParams, validateFrameParams, validateSubject, verify, verifyApproval, verifyAttestation, verifyAttestationSignature, verifyAttestationV4, verifyBoundsHash, verifyContextHash, verifyFrameHash, verifyOwnerMandate, verifyOwnerMandates, verifyReceiptSignature };

package/node_modules/@hap/core/dist/index.js

@@ -36,6 +36,7 @@ __export(index_exports, {
   approvalSigningBytes: () => approvalSigningBytes,
   attestationId: () => attestationId,
   bindingAppliesTo: () => bindingAppliesTo,
+  boundActionTypes: () => boundActionTypes,
   buildMandateProjection: () => buildMandateProjection,
   canonicalBounds: () => canonicalBounds,
   canonicalContext: () => canonicalContext,
@@ -785,6 +786,14 @@ function boundGovernsAction(fieldName, fieldDef, bt, actionType) {
   const matches = prefix === actionType || prefix.startsWith("transaction");
   return !namedForAnAction || matches;
 }
+function boundActionTypes(fieldName, fieldDef) {
+  if (fieldDef.appliesTo) return fieldDef.appliesTo;
+  const bt = fieldDef.boundType;
+  if (!bt || bt.kind !== "cumulative_count") return void 0;
+  const prefix = fieldName.replace(/_(?:daily|monthly|weekly)_max$/, "");
+  if (prefix === fieldName || prefix.startsWith("transaction")) return void 0;
+  return [prefix];
+}
 function checkBoundsV4(request, profile, executionLog, now) {
   const errors = [];
   if (!profile.boundsSchema) return errors;
@@ -845,7 +854,14 @@ function checkBoundsV4(request, profile, executionLog, now) {
           break;
         }
         if (!executionLog) break;
-        const runningTotal = executionLog.sumByWindow(profileId, path, bt.of, bt.window, now);
+        const runningTotal = executionLog.sumByWindow(
+          profileId,
+          path,
+          bt.of,
+          bt.window,
+          now,
+          boundActionTypes(fieldName, fieldDef)
+        );
         const currentRaw = request.execution[bt.of];
         const current = typeof currentRaw === "number" ? currentRaw : currentRaw !== void 0 ? Number(currentRaw) : 0;
         const total = runningTotal + current;
@@ -872,7 +888,14 @@ function checkBoundsV4(request, profile, executionLog, now) {
           break;
         }
         if (!executionLog) break;
-        const runningCount = executionLog.sumByWindow(profileId, path, "_count", bt.window, now);
+        const runningCount = executionLog.sumByWindow(
+          profileId,
+          path,
+          "_count",
+          bt.window,
+          now,
+          boundActionTypes(fieldName, fieldDef)
+        );
         const total = runningCount + 1;
         if (total > boundValue) {
           errors.push({
@@ -1207,6 +1230,7 @@ async function verifyReceiptSignature(receipt, publicKeyHex) {
   approvalSigningBytes,
   attestationId,
   bindingAppliesTo,
+  boundActionTypes,
   buildMandateProjection,
   canonicalBounds,
   canonicalContext,

package/node_modules/@hap/core/dist/index.mjs

@@ -695,6 +695,14 @@ function boundGovernsAction(fieldName, fieldDef, bt, actionType) {
   const matches = prefix === actionType || prefix.startsWith("transaction");
   return !namedForAnAction || matches;
 }
+function boundActionTypes(fieldName, fieldDef) {
+  if (fieldDef.appliesTo) return fieldDef.appliesTo;
+  const bt = fieldDef.boundType;
+  if (!bt || bt.kind !== "cumulative_count") return void 0;
+  const prefix = fieldName.replace(/_(?:daily|monthly|weekly)_max$/, "");
+  if (prefix === fieldName || prefix.startsWith("transaction")) return void 0;
+  return [prefix];
+}
 function checkBoundsV4(request, profile, executionLog, now) {
   const errors = [];
   if (!profile.boundsSchema) return errors;
@@ -755,7 +763,14 @@ function checkBoundsV4(request, profile, executionLog, now) {
           break;
         }
         if (!executionLog) break;
-        const runningTotal = executionLog.sumByWindow(profileId, path, bt.of, bt.window, now);
+        const runningTotal = executionLog.sumByWindow(
+          profileId,
+          path,
+          bt.of,
+          bt.window,
+          now,
+          boundActionTypes(fieldName, fieldDef)
+        );
         const currentRaw = request.execution[bt.of];
         const current = typeof currentRaw === "number" ? currentRaw : currentRaw !== void 0 ? Number(currentRaw) : 0;
         const total = runningTotal + current;
@@ -782,7 +797,14 @@ function checkBoundsV4(request, profile, executionLog, now) {
           break;
         }
         if (!executionLog) break;
-        const runningCount = executionLog.sumByWindow(profileId, path, "_count", bt.window, now);
+        const runningCount = executionLog.sumByWindow(
+          profileId,
+          path,
+          "_count",
+          bt.window,
+          now,
+          boundActionTypes(fieldName, fieldDef)
+        );
         const total = runningCount + 1;
         if (total > boundValue) {
           errors.push({
@@ -1116,6 +1138,7 @@ export {
   approvalSigningBytes,
   attestationId,
   bindingAppliesTo,
+  boundActionTypes,
   buildMandateProjection,
   canonicalBounds,
   canonicalContext,

package/node_modules/@hap/core/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@humanagencyp/hap-core",
-  "version": "0.10.0",
+  "version": "0.10.1",
   "description": "Core types, cryptographic primitives, and verification logic for the Human Agency Protocol",
   "license": "MIT",
   "repository": {

package/node_modules/@hap/core/src/gatekeeper.ts

@@ -469,6 +469,36 @@ function boundGovernsAction(
   return !namedForAnAction || matches;
 }
 
+/**
+ * Which action types' executions count toward this cumulative bound's running
+ * total. `undefined` means all of them.
+ *
+ * `boundGovernsAction` decides whether a bound applies to the current call; this
+ * decides what the bound's total is made of. Both are needed: selecting the right
+ * bound and then feeding it the profile's combined total is still wrong — sales'
+ * "orders per day" was checked only on orders, but counted every quote and send.
+ * Consumption is partitioned by action type (*Cumulative Tracking* rule 4), as
+ * the Authority Server already does.
+ *
+ * Same answer, same order of preference as `boundGovernsAction`: the declared
+ * `appliesTo`; else, for a count bound named for an action (`delete_daily_max`),
+ * that action; else every action type. Exported so display surfaces report the
+ * same totals the gate enforces.
+ */
+export function boundActionTypes(
+  fieldName: string,
+  fieldDef: ProfileBoundsField,
+): readonly string[] | undefined {
+  if (fieldDef.appliesTo) return fieldDef.appliesTo;
+
+  const bt = fieldDef.boundType;
+  if (!bt || bt.kind !== 'cumulative_count') return undefined;
+
+  const prefix = fieldName.replace(/_(?:daily|monthly|weekly)_max$/, '');
+  if (prefix === fieldName || prefix.startsWith('transaction')) return undefined;
+  return [prefix];
+}
+
 function checkBoundsV4(
   request: GatekeeperRequest,
   profile: AgentProfile,
@@ -552,7 +582,9 @@ function checkBoundsV4(
         }
         if (!executionLog) break;
 
-        const runningTotal = executionLog.sumByWindow(profileId, path, bt.of, bt.window, now);
+        const runningTotal = executionLog.sumByWindow(
+          profileId, path, bt.of, bt.window, now, boundActionTypes(fieldName, fieldDef),
+        );
         const currentRaw = request.execution[bt.of];
         const current = typeof currentRaw === 'number'
           ? currentRaw
@@ -584,7 +616,9 @@ function checkBoundsV4(
         }
         if (!executionLog) break;
 
-        const runningCount = executionLog.sumByWindow(profileId, path, '_count', bt.window, now);
+        const runningCount = executionLog.sumByWindow(
+          profileId, path, '_count', bt.window, now, boundActionTypes(fieldName, fieldDef),
+        );
         const total = runningCount + 1;
 
         if (total > boundValue) {

package/node_modules/@hap/core/src/types.ts

@@ -636,7 +636,27 @@ export interface ExecutionLogQuery {
    * Sum a field's values within a time window for a given profile.
    * Use field="_count" to count executions instead of summing a field.
    */
-  sumByWindow(profileId: string, path: string, field: string, window: CumulativeWindow, now?: number): number;
+  sumByWindow(
+    profileId: string,
+    path: string,
+    field: string,
+    window: CumulativeWindow,
+    now?: number,
+    /**
+     * Only count executions whose `execution.action_type` is one of these.
+     * Omitted → every execution counts (a bound that governs all action types).
+     *
+     * Consumption is partitioned by action type (*Cumulative Tracking* rule 4):
+     * a bound counts only the action types it governs. Without the filter a
+     * profile with several action types feeds every bound the combined total —
+     * sales' "orders per day" counted quotes and sends too, and its daily order
+     * value summed quote values. Use {@link boundActionTypes} to derive it.
+     *
+     * Implementations SHOULD count an entry that carries no `action_type`
+     * against every filter: an unknown action is not evidence of headroom.
+     */
+    actionTypes?: readonly string[],
+  ): number;
 }
 
 // ─── Frame Types ─────────────────────────────────────────────────────────────