@reinconsole/mock-rails 0.1.0 → 0.2.0

package/dist/index.js

@@ -47,6 +47,8 @@ var DecisionId = prefixedId("dec");
 var ReceiptId = prefixedId("rcp");
 var SessionId = prefixedId("ses");
 var GateReceiptId = prefixedId("grc");
+var ApiKeyId = prefixedId("key");
+var ApproverKeyId = prefixedId("apk");
 var EnforcementMode = z.enum(["observed", "sdk", "session-key"]);
 var AgentWallet = z.object({
   chain: Chain,
@@ -54,12 +56,15 @@ var AgentWallet = z.object({
   mode: EnforcementMode
 });
 var AgentStatus = z.enum(["active", "frozen"]);
+var AgentLabel = z.string().max(40).regex(/^[a-z0-9][a-z0-9-]*$/, 'label must be a lowercase slug like "research" or "prod-trading"');
 var Agent = z.object({
   id: AgentId,
   orgId: OrgId,
   name: z.string().min(1).max(200),
   /** On-chain ERC-8004 identity, if the agent is registered. */
   erc8004Id: z.string().optional(),
+  /** Semantic grouping labels — the targets of policy `appliesTo.labels`. */
+  labels: z.array(AgentLabel).max(16).refine((ls) => new Set(ls).size === ls.length, { message: "labels must be unique" }).default([]),
   wallets: z.array(AgentWallet).default([]),
   status: AgentStatus.default("active"),
   createdAt: z.coerce.date()
@@ -150,6 +155,17 @@ var SettledPayment = z.object({
   feePaid: DecimalString.optional(),
   confirmedAt: z.coerce.date()
 });
+var SettlementReport = z.object({
+  intentId: IntentId,
+  /** The settling transaction, when the observer saw one. */
+  txHash: z.string().optional(),
+  chain: Chain.optional(),
+  /** The amount as SETTLED, when known — may differ from the amount allowed. */
+  amount: DecimalString.optional(),
+  /** Free-form observer tag, e.g. "indexer", "guard", "facilitator". */
+  source: z.string().min(1).max(64).optional(),
+  confirmedAt: z.coerce.date()
+});
 var ReceiptSettlement = z.object({
   txHash: z.string().optional(),
   networkId: z.string().optional(),
@@ -208,15 +224,58 @@ var Condition = z.object({
   txCount: z.object({ window: Window, gt: z.number().int().nonnegative() }).optional(),
   /** Vendor host matches one of these patterns (supports `*` globs). */
   vendorHostIn: z.array(z.string()).optional(),
+  /**
+   * Resource PATH matches one of these patterns (supports `*` globs, e.g.
+   * "/v1/reports/*"). A full-URL resource is reduced to its pathname before
+   * matching (see `resourcePathOf`), so the same pattern works whether the
+   * vendor declares "https://api.x.com/v1/answer" or "/v1/answer". Pair
+   * with `vendorHostIn` to scope a path rule to specific vendors.
+   */
+  resourceIn: z.array(z.string()).optional(),
   /** First time Rein has seen this vendor for the agent. */
   vendorFirstSeen: z.boolean().optional(),
   /** Vendor reputation score is below this threshold (Phase 3 hook). */
   vendorReputationLt: z.number().min(0).max(100).optional(),
   /** Amount is more than `gt`-times the observed median for this resource. */
-  amountVsResourceMedian: z.object({ gt: Multiplier }).optional()
+  amountVsResourceMedian: z.object({ gt: Multiplier }).optional(),
+  /**
+   * Cumulative spend attributed to THIS intent's `taskContext.taskId`
+   * (prior spend on the task plus this payment) exceeds `gt`. Scopes a
+   * budget to one unit of work rather than to a window: a research run that
+   * is meant to cost a dollar cannot quietly cost fifty, however slowly.
+   *
+   * An intent carrying no `taskId` cannot be attributed to a task, so the
+   * predicate never triggers for one. Requiring attribution is a separate,
+   * deliberate rule (deny on `taskIdMissing`), not a side effect of setting
+   * a budget — otherwise every untagged probe payment would trip every
+   * task budget in the policy.
+   */
+  taskBudget: z.object({ gt: DecimalString }).optional(),
+  /** The intent carries no `taskContext.taskId` (or an empty one). */
+  taskIdMissing: z.boolean().optional()
 }).refine((c) => Object.values(c).some((v) => v !== void 0), {
   message: "a condition must specify at least one predicate"
 });
+var Breaker = z.object({
+  id: z.string().min(1),
+  /** The trailing span the tripwires measure over. */
+  window: Window,
+  /**
+   * Trip when the window would hold MORE than this many transactions.
+   * `10` permits ten in the window and escalates the eleventh.
+   */
+  txCount: z.number().int().positive().optional(),
+  /**
+   * Trip when the window's spend would exceed this total. `"50.00"` permits
+   * a window totalling exactly 50.00 and escalates the payment that would
+   * carry it past. Prospective, like every other spend predicate: the
+   * payment that would breach the cap is the one that escalates, rather
+   * than the innocent one after it.
+   */
+  valueCap: DecimalString.optional()
+}).refine((b) => b.txCount !== void 0 || b.valueCap !== void 0, {
+  message: "a breaker must specify at least one of txCount / valueCap"
+});
 var Rule = z.object({
   id: z.string().min(1),
   allow: Condition.optional(),
@@ -229,6 +288,13 @@ var PolicyDefault = z.enum(["allow", "deny"]);
 var AppliesTo = z.object({
   /** Agent id patterns (supports `*` globs, e.g. "agt_research_*"). */
   agents: z.array(z.string()).optional(),
+  /**
+   * Agent label patterns (supports `*` globs) — semantic targeting. Matches
+   * when the agent carries at least one label matching any pattern. Requires
+   * the agent DOCUMENT: an intent from an unregistered agent never matches a
+   * labels-targeted policy (and so fails closed when no other policy applies).
+   */
+  labels: z.array(z.string()).optional(),
   chains: z.array(Chain).optional()
 });
 var Escalation = z.object({
@@ -241,11 +307,134 @@ var Policy = z.object({
   version: z.string().default("1"),
   appliesTo: AppliesTo.default({}),
   rules: z.array(Rule).default([]),
+  /**
+   * Behavioral breakers evaluated alongside the rules. A tripped breaker
+   * escalates at the same precedence as an `escalate` rule — so an explicit
+   * DENY still wins, and an ALLOW rule cannot wave past a tripped breaker.
+   */
+  breakers: z.array(Breaker).default([]),
   default: PolicyDefault.default("deny"),
   /** Below this amount, fail-open is permitted during a policy-service outage. */
   denyFloor: DecimalString.default("0.05"),
   escalation: Escalation.optional()
 });
+var LivenessSource = z.enum([
+  /** It submitted an intent — ANY outcome, including a denial. */
+  "intent",
+  /** It reported in explicitly, having nothing to buy. */
+  "heartbeat"
+]);
+var DEFAULT_LIVENESS_GRACE_MS = 6e4;
+var LivenessExpectation = z.object({
+  agentId: AgentId,
+  /** Longest silence still considered normal, e.g. '15m'. */
+  interval: Window,
+  /** Extra slack past `interval` before the silence is an alarm. */
+  graceMs: z.number().int().nonnegative().default(DEFAULT_LIVENESS_GRACE_MS),
+  /**
+   * When watching began. An agent that has NEVER been seen is measured from
+   * here, so a watch on an agent that never starts does raise an alarm — a
+   * detector that never came up is exactly as dead as one that stopped.
+   */
+  since: z.coerce.date(),
+  /** What this agent is supposed to be doing, shown beside the alarm. */
+  note: z.string().max(200).optional()
+});
+var LivenessWatchInput = LivenessExpectation.omit({ since: true }).extend({
+  graceMs: z.number().int().nonnegative().optional()
+});
+var Heartbeat = z.object({
+  agentId: AgentId,
+  /** When the agent was alive. Defaults to arrival time. */
+  at: z.coerce.date().optional(),
+  /** Free-form note from the reporter, e.g. "poll cycle 41 ok". */
+  note: z.string().max(200).optional()
+});
+var LivenessStatus = z.enum(["alive", "late", "missing", "unknown"]);
+var ApiKeyScope = z.enum(["read", "evaluate", "approve", "admin"]);
+var ApiKey = z.object({
+  id: ApiKeyId,
+  name: z.string().min(1).max(200),
+  scopes: z.array(ApiKeyScope).min(1),
+  createdAt: z.coerce.date(),
+  /** Last successful authentication, for spotting keys that can be retired. */
+  lastUsedAt: z.coerce.date().optional(),
+  /** Set by revoke(); a revoked key never authenticates again. */
+  revokedAt: z.coerce.date().optional(),
+  /** Set by rotate(); with `previousSecretExpiresAt` it dates the overlap. */
+  rotatedAt: z.coerce.date().optional()
+});
+var ApiKeyRecord = ApiKey.extend({
+  secretHash: z.string(),
+  previousSecretHash: z.string().optional(),
+  previousSecretExpiresAt: z.coerce.date().optional()
+});
+var ApprovalVerdict = z.enum(["approve", "reject"]);
+var ApprovalStatus = z.enum(["pending", "approved", "rejected", "expired"]);
+var ApproverKey = z.object({
+  id: ApproverKeyId,
+  orgId: OrgId,
+  name: z.string().min(1).max(200),
+  /** ed25519 public key, SPKI PEM — the same encoding as the decision log's. */
+  publicKey: z.string().min(1),
+  algorithm: z.literal("ed25519").default("ed25519"),
+  createdAt: z.coerce.date(),
+  revokedAt: z.coerce.date().optional()
+});
+var ApprovalRequest = z.object({
+  /** The `escalate` decision this request answers (primary key). */
+  decisionId: DecisionId,
+  intentId: IntentId,
+  /** Binds the approval to the exact transfer — the signed bytes commit to it. */
+  intentHash: z.string(),
+  agentId: AgentId,
+  vendorHost: z.string(),
+  resource: z.string(),
+  amount: DecimalString,
+  asset: Asset,
+  chain: Chain,
+  /**
+   * Task attribution copied from the intent. Carried so an approved payment
+   * still counts against its `taskBudget` — an escalation that lost its task
+   * id on the way through would make the budget silently under-count exactly
+   * the payments a human had to look at.
+   */
+  taskId: z.string().optional(),
+  /** Why policy escalated, verbatim from the decision. */
+  reason: z.string(),
+  /**
+   * Breaker ids whose trip contributed to this escalation. An approval of
+   * this request resets exactly these — moving their counting floor to the
+   * approval instant — so a human waving one payment through also clears the
+   * behavior that stopped it, rather than being asked again immediately.
+   * Empty when ordinary rules did the escalating.
+   */
+  breakers: z.array(z.string()).default([]),
+  status: ApprovalStatus,
+  createdAt: z.coerce.date(),
+  /** Past this instant the request denies, whatever arrives afterwards. */
+  expiresAt: z.coerce.date(),
+  resolvedAt: z.coerce.date().optional(),
+  /** Which registered key signed — absent when the TTL lapsed instead. */
+  approverKeyId: ApproverKeyId.optional(),
+  /**
+   * The follow-up decision appended to the chain when this resolved. That
+   * decision, not this record, is the voucher a signer verifies: the original
+   * `escalate` decision is never rewritten.
+   */
+  finalDecisionId: DecisionId.optional()
+});
+var ApprovalChallenges = z.object({
+  approve: z.string(),
+  reject: z.string()
+});
+var ApprovalGrant = z.object({
+  decisionId: DecisionId,
+  intentHash: z.string(),
+  verdict: ApprovalVerdict,
+  approverKeyId: ApproverKeyId,
+  signature: z.string().min(1)
+});
 var ReputationSubject = z.object({
   kind: z.enum(["agent", "vendor"]),
   id: z.string()
@@ -307,6 +496,36 @@ var ReinEvent = z.discriminatedUnion("type", [
     network: z.string()
   }),
   z.object({ type: z.literal("gate.settled"), at: z.coerce.date(), receipt: GateReceipt }),
+  z.object({
+    type: z.literal("approval.requested"),
+    at: z.coerce.date(),
+    request: ApprovalRequest
+  }),
+  z.object({
+    type: z.literal("approval.resolved"),
+    at: z.coerce.date(),
+    request: ApprovalRequest,
+    /** The follow-up allow/deny decision this resolution appended. */
+    decision: Decision
+  }),
+  z.object({
+    type: z.literal("liveness.missing"),
+    at: z.coerce.date(),
+    agentId: AgentId,
+    expectation: LivenessExpectation,
+    /** How long the agent has been silent when the alarm was raised. */
+    silentMs: z.number().int().nonnegative(),
+    /** Last sighting, absent when the agent was never seen at all. */
+    lastSeenAt: z.coerce.date().optional()
+  }),
+  z.object({
+    type: z.literal("liveness.recovered"),
+    at: z.coerce.date(),
+    agentId: AgentId,
+    /** How long the silence lasted, measured to this sighting. */
+    silentMs: z.number().int().nonnegative(),
+    source: LivenessSource
+  }),
   z.object({
     type: z.literal("gate.refused"),
     at: z.coerce.date(),
@@ -351,8 +570,79 @@ var MockLedger = class {
 
 // ../../packages/sdk/dist/index.js
 import { z as z2 } from "zod";
-var Health = z2.object({ status: z2.string(), publicKey: z2.string() });
-var EvaluateResponse = z2.object({ intent: PaymentIntent, decision: Decision });
+var BreakerState = z2.object({
+  breaker: Breaker,
+  policyId: z2.string(),
+  txCount: z2.number(),
+  sum: z2.string(),
+  countingFrom: z2.number(),
+  resetAt: z2.number().optional(),
+  tripped: z2.boolean(),
+  reason: z2.string().optional()
+});
+var LivenessState = z2.object({
+  agentId: z2.string(),
+  expectation: LivenessExpectation,
+  lastSeenAt: z2.number().optional(),
+  lastSource: LivenessSource.optional(),
+  silentSince: z2.number(),
+  silentMs: z2.number(),
+  dueAt: z2.number(),
+  overdueAt: z2.number(),
+  status: LivenessStatus,
+  alertedAt: z2.number().optional()
+});
+var Health = z2.object({
+  status: z2.string(),
+  publicKey: z2.string(),
+  /** "api-key" once the engine demands a credential; "none" while it does not. */
+  auth: z2.string().optional(),
+  approvals: z2.string().optional()
+});
+var EvaluateResponse = z2.object({
+  intent: PaymentIntent,
+  decision: Decision,
+  /** Present when an escalation was parked for a signed verdict. */
+  approval: ApprovalRequest.optional()
+});
+var ApprovalView = z2.object({
+  request: ApprovalRequest,
+  challenges: ApprovalChallenges,
+  /** The follow-up allow/deny decision, once the request has resolved. */
+  decision: Decision.optional()
+});
+var ResolveResponse = z2.object({ request: ApprovalRequest, decision: Decision });
+var AllowanceGap = z2.object({
+  intentId: z2.string(),
+  decisionId: z2.string().optional(),
+  agentId: z2.string(),
+  host: z2.string(),
+  resource: z2.string(),
+  amount: z2.string(),
+  taskId: z2.string().optional(),
+  allowedAt: z2.number(),
+  ageMs: z2.number(),
+  state: z2.enum(["in-flight", "unsettled"])
+});
+var ReconciliationReport = z2.object({
+  from: z2.number(),
+  to: z2.number(),
+  window: z2.string(),
+  graceMs: z2.number(),
+  allowed: z2.number(),
+  allowedValue: z2.string(),
+  settled: z2.number(),
+  settledValue: z2.string(),
+  inFlight: z2.number(),
+  inFlightValue: z2.string(),
+  unsettled: z2.number(),
+  unsettledValue: z2.string(),
+  unattributed: z2.number(),
+  settlementsSeen: z2.number(),
+  gaps: z2.array(AllowanceGap),
+  truncated: z2.boolean()
+});
+var IssuedApiKey = z2.object({ key: ApiKey, secret: z2.string() });
 var PaymentRequirement = z2.object({
   scheme: z2.string(),
   network: z2.string(),
@@ -417,6 +707,81 @@ function requirementDecimals(requirement) {
   const decimals = requirement.extra?.["decimals"];
   return typeof decimals === "number" && Number.isInteger(decimals) && decimals >= 0 ? decimals : 6;
 }
+var CAIP2_ALIASES = {
+  base: "eip155:8453",
+  "base-sepolia": "eip155:84532",
+  polygon: "eip155:137",
+  "polygon-amoy": "eip155:80002",
+  bnb: "eip155:56",
+  bsc: "eip155:56",
+  solana: "solana:5eykt4UsFv8P8NJdTREpY1vzqKqZKvdp",
+  "solana-devnet": "solana:EtWTRABZaYq6iMfeYKouRu166VU2xqa1"
+};
+function caip2Of(network) {
+  const key = network.toLowerCase();
+  return CAIP2_ALIASES[key] ?? key;
+}
+function sameNetwork(a, b) {
+  return caip2Of(a) === caip2Of(b);
+}
+var PaymentRequirementsV2 = z2.object({
+  scheme: z2.string(),
+  /** CAIP-2, e.g. "eip155:84532". */
+  network: z2.string(),
+  /** Atomic units — v2's rename of v1's maxAmountRequired. */
+  amount: z2.string().regex(/^\d+$/, "atomic amount must be an integer string"),
+  asset: z2.string().min(1),
+  payTo: z2.string().min(1),
+  maxTimeoutSeconds: z2.number().optional(),
+  extra: z2.record(z2.unknown()).optional()
+});
+var ResourceInfoV2 = z2.object({
+  url: z2.string(),
+  description: z2.string().optional(),
+  mimeType: z2.string().optional()
+});
+var PaymentRequiredV2 = z2.object({
+  x402Version: z2.literal(2),
+  error: z2.string().optional(),
+  resource: ResourceInfoV2.optional(),
+  accepts: z2.array(PaymentRequirementsV2).min(1),
+  extensions: z2.record(z2.unknown()).optional()
+});
+function v2Requirements(requirement) {
+  return {
+    scheme: requirement.scheme,
+    network: caip2Of(requirement.network),
+    amount: requirement.maxAmountRequired,
+    asset: requirement.asset,
+    payTo: requirement.payTo,
+    ...requirement.maxTimeoutSeconds !== void 0 ? { maxTimeoutSeconds: requirement.maxTimeoutSeconds } : {},
+    ...requirement.extra ? { extra: requirement.extra } : {}
+  };
+}
+function buildPaymentRequiredV2(requirement, error) {
+  return {
+    x402Version: 2,
+    error,
+    ...requirement.resource ? {
+      resource: {
+        url: requirement.resource,
+        ...requirement.description ? { description: requirement.description } : {},
+        ...requirement.mimeType ? { mimeType: requirement.mimeType } : {}
+      }
+    } : {},
+    accepts: [v2Requirements(requirement)],
+    extensions: {}
+  };
+}
+function encodeBase64Json(value) {
+  return Buffer.from(JSON.stringify(value)).toString("base64");
+}
+var V1Envelope = z2.object({
+  x402Version: z2.literal(1),
+  scheme: z2.string(),
+  network: z2.string(),
+  payload: z2.record(z2.unknown())
+});
 
 // src/errors.ts
 var FacilitatorError = class extends Error {
@@ -450,6 +815,17 @@ var MockPaymentHeader = z3.object({
   network: z3.string(),
   payload: MockExactPayload
 });
+var MockPaymentHeaderV2 = z3.object({
+  x402Version: z3.literal(2),
+  accepted: z3.object({
+    scheme: z3.string(),
+    network: z3.string(),
+    amount: z3.string().regex(/^\d+$/, "atomic amount must be an integer string"),
+    asset: z3.string().min(1),
+    payTo: z3.string().min(1)
+  }).passthrough(),
+  payload: MockExactPayload
+}).passthrough();
 function encodePaymentHeader(header) {
   return Buffer.from(JSON.stringify(header)).toString("base64");
 }
@@ -460,11 +836,37 @@ function decodePaymentHeader(raw) {
   } catch {
     throw new FacilitatorError("malformed_payment", "X-PAYMENT is not base64-encoded JSON");
   }
+  if (json?.x402Version === 2) {
+    const parsed2 = MockPaymentHeaderV2.safeParse(json);
+    if (!parsed2.success) {
+      throw new FacilitatorError(
+        "malformed_payment",
+        `invalid v2 payment envelope: ${parsed2.error.message}`
+      );
+    }
+    if (parsed2.data.payload.value !== parsed2.data.accepted.amount) {
+      throw new FacilitatorError(
+        "malformed_payment",
+        `v2 envelope contradicts itself: accepted.amount ${parsed2.data.accepted.amount} vs payload value ${parsed2.data.payload.value}`
+      );
+    }
+    return {
+      version: 2,
+      scheme: parsed2.data.accepted.scheme,
+      network: parsed2.data.accepted.network,
+      payload: parsed2.data.payload
+    };
+  }
   const parsed = MockPaymentHeader.safeParse(json);
   if (!parsed.success) {
     throw new FacilitatorError("malformed_payment", `invalid X-PAYMENT body: ${parsed.error.message}`);
   }
-  return parsed.data;
+  return {
+    version: 1,
+    scheme: parsed.data.scheme,
+    network: parsed.data.network,
+    payload: parsed.data.payload
+  };
 }
 var SettlementResponse = z3.object({
   success: z3.boolean(),
@@ -507,7 +909,8 @@ var MockFacilitator = class {
       }
     });
   }
-  /** Verify an X-PAYMENT header against the requirement it claims to satisfy. */
+  /** Verify a payment header (either dialect) against the requirement it
+   *  claims to satisfy. */
   verify(paymentHeader, requirement) {
     const header = decodePaymentHeader(paymentHeader);
     if (header.scheme.toLowerCase() !== "exact" || requirement.scheme.toLowerCase() !== "exact") {
@@ -516,7 +919,7 @@ var MockFacilitator = class {
         `mock facilitator only settles "exact", got "${header.scheme}"/"${requirement.scheme}"`
       );
     }
-    if (header.network !== requirement.network) {
+    if (!sameNetwork(header.network, requirement.network)) {
       throw new FacilitatorError(
         "network_mismatch",
         `payment is on "${header.network}" but the requirement wants "${requirement.network}"`
@@ -675,6 +1078,7 @@ function sameAddress(a, b) {
 // src/vendor.ts
 function createMockVendor(options) {
   const calls = [];
+  const advertise = options.advertise ?? "v1";
   const requirementFor = (url) => PaymentRequirement.parse({
     scheme: options.scheme ?? "exact",
     network: options.network ?? "base",
@@ -683,18 +1087,27 @@ function createMockVendor(options) {
     payTo: options.payTo,
     asset: options.asset ?? "USDC"
   });
-  const paymentRequired = (url, error) => new Response(
-    JSON.stringify({ x402Version: 1, accepts: [requirementFor(url)], error }),
-    { status: 402, headers: { "content-type": "application/json" } }
-  );
+  const paymentRequired = (url, error) => {
+    const requirement = requirementFor(url);
+    const body = advertise === "v2" ? { error } : { x402Version: 1, accepts: [requirement], error };
+    return new Response(JSON.stringify(body), {
+      status: 402,
+      headers: {
+        "content-type": "application/json",
+        ...advertise !== "v1" ? {
+          "PAYMENT-REQUIRED": encodeBase64Json(buildPaymentRequiredV2(requirement, error))
+        } : {}
+      }
+    });
+  };
   const fetch = async (input, init) => {
     const url = typeof input === "string" ? input : input instanceof URL ? input.toString() : input.url;
     const headers = new Headers(
       init?.headers ?? (input instanceof Request ? input.headers : void 0)
     );
-    const payment = headers.get("X-PAYMENT");
+    const payment = headers.get("PAYMENT-SIGNATURE") ?? headers.get("X-PAYMENT");
     calls.push({ url, payment });
-    if (payment === null) return paymentRequired(url, "X-PAYMENT header is required");
+    if (payment === null) return paymentRequired(url, "payment is required");
     let settled;
     try {
       settled = options.facilitator.settle(payment, requirementFor(url));
@@ -704,7 +1117,13 @@ function createMockVendor(options) {
     }
     return new Response(JSON.stringify(options.body ?? { ok: true }), {
       status: 200,
-      headers: { "content-type": "application/json", "X-PAYMENT-RESPONSE": settled.header }
+      headers: {
+        "content-type": "application/json",
+        // Both dialect names carry the same base64 settlement object; the
+        // strict v2 vendor sets ONLY the v2 name.
+        ...advertise !== "v2" ? { "X-PAYMENT-RESPONSE": settled.header } : {},
+        "PAYMENT-RESPONSE": settled.header
+      }
     });
   };
   return { fetch, calls, requirementFor };
@@ -716,6 +1135,7 @@ export {
   MockIndexer,
   MockLedger,
   MockPaymentHeader,
+  MockPaymentHeaderV2,
   SettlementResponse,
   createMockVendor,
   decodePaymentHeader,