All notable changes to this project are documented in this file.

The format is based on Keep a Changelog.

3.3.0 - 2026-11-17

Added

  • Providers may return bounded verified facts, stored with the receipt and delivered to handlers when record_verified_facts :on is enabled. The Plug resolver and direct ingress accept transient upstream host_context.
  • Endpoint signers receive the complete ordered HTTP request and delivery, endpoint, attempt, event and tenant context. Optional native signing supports host-only endpoints and custody-safe transitions between signing modes.
  • Prepared requests preserve the request target, header lines and body through capable adapters. Bounded implements the contract; host signing refuses an adapter without send_prepared/2 before calling the signer.
  • Optional record_signing_provenance :on records every signing key reference, including durable 410 recovery. Signing telemetry reports duration and outcome.

Changed

  • CI separates static checks from tests and enforces Mix-written lock bytes and the repository secret-scan rules.

  • The optional Plug dependency requires 1.20.4 or later in the 1.x series, excluding versions affected by CVE-2026-120287. The development lock uses Plug 1.20.4.

  • Ingress and dispatch share one bounded SQLite contention policy for fenced or idempotent writes and the idempotent reads around them. Mixed error sets are never retried.

  • Development and CI runtime versions come from .tool-versions files. CI tests the version-file parser before constructing its matrix.

  • The optional Oban dependency now requires ~> 2.24, whose service options support the documented insert-only instance.

  • The Spark dependency floor is 2.7.6, matching Ash 3.37.2. Both exact versions pass the fresh dependency-floor qualification.

Fixed

  • The 3.0 upgrade guide gives tested replacement configurations, event mappings, and delivery identities for every removed vendor verifier module.

  • Generated HTML is checked without rewriting ExDoc output. Only the page-title and index redirect template separators are exempt, anchored to the build's project name and version. Authored title and body dashes remain rejected.

  • Shipped examples have explicit execution dispositions and use the exported consumer formatter settings. Upgrade and contributor commands explain their host project and service requirements. Phoenix mounting examples retain the consumer DSL syntax; formatter checks use dependency exports and report missing dependencies without changing the examples.

  • A legacy-only attempt records its legacy signing reference. New event-log replay rows inherit their matching subscription's signing mode across all read pages. No match retains :standard; conflicting matching modes are skipped.

  • Httpc does not advertise prepared-request transport: qualification found target percent-escape normalization even with headers_as_is. Host signers use Bounded or a custom adapter that fulfills the exact-byte contract.

  • Conditional 410 disablement handles nullable native references and compares declared host signer attributes through their Ash types. Missing attributes in older snapshots protect the endpoint from stale disablement.

  • The installer resolves parser aliases and preserves existing body readers. It adds notices for custom readers and endpoint configurations that need manual setup, and remains safe to rerun.

  • Ingress records out-of-contract handler and parser results as retryable invalid_handler_result failures under the claim fence. Every recorded failure emits ingress telemetry; stale owners only reload the receipt. Every {:ok, value} remains a processed success, including non-struct values. Parser crashes while driving a claimed receipt finalize as retryable handler_crashed failures.

  • Row-security documentation separates tenant-bound Oban insertion from queue execution under a dedicated engine role, with forced policies on jobs and peers, least-privilege grants, and both instance configurations. PostgreSQL tests execute the guide's SQL and configurations as restricted login roles, exercise real queue transitions and notifications, and check tenant isolation.

  • Legacy verification authenticates the signature before checking the replay window. A tampered stale request returns :invalid_signature; an authentic stale request still returns :stale_timestamp.

  • Inbound observation counts use data-layer count and sum aggregates without loading ledger rows. Storage read failures return errors instead of successful zero counts. Endpoint health sweeps report unread histories in unread and emit [:ash_hooks, :endpoint_health, :read_failed], preserving the affected endpoint's status and warning marker while considering other endpoints.

  • Standard Webhooks verification authenticates the signature before checking the timestamp window for both HMAC and Ed25519. A bad signature with a stale timestamp now returns :invalid_signature; an authentic stale request still returns :timestamp_out_of_tolerance.

3.2.0 - 2026-11-15

Added

  • AshHooks.Custody.canonical_tenant/3 and tenant_type_supported?/2 expose tenant canonicalization and tenant-type support checks. The canonicalizer returns {:error, :invalid_tenant} for rejected values and {:error, :unsupported_tenant_type} for unsupported types. The support check returns a boolean.

  • AshHooks.Custody.PublicKey and new/2 validate pinned asymmetric material against its declared algorithm, digest, padding, and curve.

  • AshHooks.Tenancy.from_row/1 recovers a stored row's tenant through tenant_from_attribute before reuse in tenant options or custody.

  • AshHooks.InboundSource options ledger, source_attribute, scope, providers, custodian, custody_tenant_key, key_registry, max_overlap_seconds, and default_overlap_seconds configure source identity, provider selection, custody, and rotation.

  • AshHooks.InboundSource.create_source/3, roll_secret/2, reissue_secret/2, schedule_previous_retirement/3, expire_previous_secret/2, expire_previous_secrets/2, register_public_key/3, pause/2, and unpause/2 expose source issuance, lost-disclosure recovery, retirement, public-key registration, and pause control.

  • AshHooks.InboundSource.adopt_provider_alias/4 returns :invalid_limit, :source_mismatch, or :provider_mismatch for invalid adoption arguments.

  • AshHooks.Ingress.resolve_source/3 and AshHooks.Inbound.ResolvedSource expose resolved provider, cast scope, pause state, and verification keys. Pass the result through the :resolved_source ingest context to reuse it.

  • Endpoint option secret_resolver resolves unmarked byte slots during migration.

  • Registry option issue_timeout defaults to 900 seconds. AshHooks.KeyRegistry.sweep/2 reconciles owners and destroys retired keys. The extension injects :read, :issue_key, :transition_key, and :prune_keys when absent. Destruction failures emit [:ash_hooks, :key_registry, :destroy_failed] with measurement %{count: 1} and metadata registry, ref, and reason.

  • AshHooks.Provider.Scheme.decode_payload/3 accepts a JSON decoder, and AshHooks.Provider.Signature.jws/3 accepts the json_decoder: option for protected headers and claims.

  • Monitored delivery and finalization children inherit the caller's configured tracer context.

  • AshHooks.InboundSource owns inbound custody keys, provider aliases, pause, rotation, retirement, and public verification keys on a host Ash resource. Source and ledger tenancy and scope have compile-time checks and request preflight. Creation and rotation reuse the endpoint issuing and lifecycle core.

  • Inbound ledgers can record the authenticating provider alias. Claims and recovery use that durable alias without consulting the source row. adopt_provider_alias/4 stamps and claims older receipts in bounded tenant phases, with handlers running after each claim commits.

  • Optional provider callback arities accept AshHooks.Provider.DeliveryContext with tenant, source, scope, provider alias, and persisted delivery identity. The callbacks are parse_event_type/2, event_identity/2, and handle_event/3.

  • Endpoint custody key issuance through create_with_key/3, roll_secret/2 with material: or generate:, and reissue_secret/2 for lost disclosures. Generation returns a one-time secret or Ed25519 public half without storing the disclosure on the endpoint. Issues commit before storage; attachment, persisted ownership, and replacement retirement share one tenant transaction.

  • AshHooks.Endpoint.adopt_keys/2 adopts occupied standard current and previous byte slots through secret_resolver while preserving lifecycle timestamps. Legacy slots also adopt with legacy_key_lifecycle :on; otherwise they remain host byte references and keep signing through secret_resolver. Existing custody slots remain unchanged. Failed attempts retire their issued references, and the registry sweep disposes of abandoned issues after crashes.

  • Custody endpoints without a byte resolver require create_with_key/3 for creation and refuse caller-chosen references when rolling. Issuing operations refuse enclosing transactions, unsupported generation kinds, expired issues, and persisted owners that do not hold the issued keys in their intended slots.

  • Outbound custody signing for Standard Webhooks and legacy envelopes, including mixed custody and byte slots during migration. Slot kind markers select each signer; sender-only kinds are refused before custody is called.

  • Inbound HMAC primitives and configured providers accept opaque custody keys, rotation lists, and mixed byte and custody keys with classified failures.

  • Endpoint option custody_tenant_key defines the host's equality contract for custom tenant types. Custody endpoints refuse unsupported types without it.

  • Opt-in key_material: :custody_only refuses endpoint and worker byte resolvers, inbound byte-secret sources, and provider signing-secret callbacks at compile time.

  • Bounded tenant transactions for every package database phase. Reads use the write repository on AshPostgres and transactional AshSqlite resources. The new row-level security guide explains repository binding, table and job policies, and per-tenant sweeps.

  • Inbound ledger option json_decoder applies an application JSON policy to JWS protected headers, claims, and delivered payloads for each request.

  • Optional provider callback decode_payload/2 receives the request's JSON decoder. Ledgers configuring json_decoder require it for host-defined decode_payload/1; generated decoders honor the policy directly.

  • AshHooks.Provider.Conformance checks that a hand-written decode_payload/2 uses the supplied JSON decoder. ExUnit is required only in consumer tests.

  • AshHooks.KeyRegistry, a host-resource extension for durable custody-key disposal. Issued references survive crashes, attachment and retirement share the owner's transaction, and sweeps reconcile every owner deletion path. Destruction uses the recorded canonical tenant outside transactions, retries outages with capped exponential backoff, and parks classified final failures. Operators can inspect pending/2, repair and rearm/3, and prune/2 old destroyed rows. Generation fences reject stale destruction results.

  • Endpoint options custodian and key_registry inject per-slot kind markers with lifecycle tracking. Each slot's marker distinguishes custody references from host byte references; rolling moves the marker with its reference, and expiration retires custody references in the owner transaction.

  • Subscription option pausable :on injects a nonnullable boolean paused column, defaulting to false. Paused subscriptions create no new delivery rows; existing deliveries continue. The default :off keeps existing schemas unchanged. Applications pause and resume through ordinary updates.

  • Endpoint option legacy_key_lifecycle :on opts legacy signing keys into overlap validation, retirement scheduling, signing deadlines, and fenced first-use timestamps. It requires key_lifecycle :on and a migration for five nullable timestamp columns; the default is :off.

  • Endpoint lifecycle helpers accept slot: :standard | :legacy (default :standard). Rolling validates a new reference against both the incumbent and previous reference of the selected slot. Each operation leaves the other slot unchanged.

  • AshHooks.Ssrf.resolve_host_public/2 validates DNS names and IP literals, resolves both address families under a bounded deadline, and returns only public addresses for connection pinning.

  • Endpoint options max_overlap_seconds and default_overlap_seconds configure the maximum and default overlap for the selected standard or legacy slot. Rolling refuses negative or non-integer durations with {:error, :invalid_overlap} and durations above the cap with {:error, {:overlap_exceeds_max, max}}. Retirement scheduling honors the same cap, measured from the application clock.

  • AshHooks.Endpoint.schedule_previous_retirement/3 sets a retirement time for the selected standard or legacy previous key, including an undated reference adopted with key_lifecycle :on. Past times and absent previous references are refused.

  • AshHooks.Custody, a public key-custody behavior with kind assertions, canonical tenant identities, global tenant binding, and permanent reference tombstones; AshHooks.Custody.Key carries opaque key metadata.

  • AshHooks.Custody.Conformance, test support for custodians covering key bounds, signatures, fingerprints, tenant isolation, and store/destroy ordering. ExUnit is required only by the consumer's tests.

  • AshHooks.Signing.display_fingerprint/1 for spec-shaped keys and AshHooks.Custody.display_fingerprint/1 for opaque spec keys, using a domain-separated fingerprint shared by both halves of an Ed25519 pair. Sender and legacy keys have no display fingerprint. Fingerprints do not protect weak secrets against offline guessing.

  • Classified UnknownSource, KeyKindMismatch, UnknownKey, and KeyUnavailable errors with fixed telemetry reason tokens.

Changed

  • Every inbound declaration now casts and constrains scope through its ledger attributes before verification, including declarations without source_record. Missing, nil, or invalid scope returns MalformedPayload; provider callbacks receive cast values.

Fixed

  • Add regression tests for parsed tenant values, key-kind mismatches, all signing modes, and owners deleted during a custody-key refresh.

  • Verify that a history-deletion failure rolls back joined delivery pruning on both supported databases.

  • Handle an enqueue refused inside a host transaction like that path's other enqueue failures, with dispatch marking joining the host transaction.

  • Preserve declaration handshake and response policies on source-resolution failures; only an absent source row gets the early 404 response.

  • Validate pinned public-key kinds before writes and pass typed public keys to providers, preventing an HMAC alias from accepting public-key forgeries.

  • Recover stored row tenants through tenant_from_attribute before custody canonicalization and every tenant option, including non-identity parsers.

  • Refresh displaced custody references once from their owner during signing and verification, preserving immediate destruction without false dead letters.

  • Refuse direct custody-kind input on host actions while preserving byte-only reference writes through a configured resolver.

  • Refuse retirement of an unattached custody reference and roll back the owner write; byte slots remain outside the registry during partial adoption.

  • Keep an issuing failure's original classification when cleanup also fails.

  • Contain custodian callback faults as classified outages, retry outbound attempts, and avoid recording outages as failed-verification rejections.

  • Refuse a ledger declaration whose source resource belongs to another ledger.

  • Apply a ledger's configured json_decoder requirement to every provider in a source declaration's allowlist, so a host-defined decode_payload/1 without /2 cannot bypass the decoding policy through a source alias.

  • Preserve classified provider errors during key overlaps, including timestamp and payload failures from either authenticating key.

  • During an inbound rotation overlap, when the current key fails with an invalid signature and the previous key cannot be checked (its key is unavailable, unknown or of the wrong kind, or its verification failed in an unrecognized way), ingress now reports the previous key's failure instead of InvalidSignature. A request signed with the previous key is answered as a key or availability failure (500 or 503 from AshHooks.Plug), never as a forged request. Request failures such as a stale timestamp still report the current key's result.

  • Every verifier that tries several keys reports the same ranked result. AshHooks.Provider.Hmac.verify_signature/4 accepts custody keys, alone or mixed with byte keys, and returns a custody failure ahead of a MAC mismatch instead of reducing it to :invalid_signature. An AshHooks.Custody.Key in an RSA, ECDSA or Ed25519 key list reports KeyKindMismatch unless another key verifies, instead of InvalidSignature.

  • Package database phases pass Ash.transact/3 the tenant key, converted with Ash.ToTenant for every resource in the phase, because a transaction reason names no resource. A phase whose resources convert the tenant differently returns {:error, :tenancy_mismatch} before opening a transaction. The row security guide's repository callback converts an action's tenant with the resource named in its transaction reason.

  • Run every shipped documentation code block or state why it cannot run in the documentation gate. Check consumer formatting for Elixir examples, including module documentation, DSL references, and Livebook cells.

  • Replace the tenancy adoption backfill placeholders with executable SQL and verify that every legacy row has a tenant on SQLite and PostgreSQL.

  • The formatter configuration exported to consumers lists every ash_hooks DSL option, including provider, subscriptions, deliveries, paused and previous_secret. A consumer importing :ash_hooks in import_deps no longer has mix format add parentheses to the documented DSL. The list is generated from the DSL and checked for drift.

  • Key registry refusals before any write leave an enclosing host transaction usable. Sweeps refuse a native SQLite transaction even when Ash write transactions are disabled.

  • AshHooks.Delivery.run/2 and test_send/2 refuse an enclosing transaction with {:error, :inside_transaction} before starting work. Previously their monitored child could block or miss uncommitted rows. Inline driver enqueue refusal reports :enqueue_failed and leaves the delivery :pending.

  • Custody lifecycle retirement checks the persisted owner after each write and retains references still held in any slot, including after a concurrent roll or a host action that returns an outdated record.

  • Lifecycle refusals leave enclosing host transactions usable for custody and byte slots. Failures after an owner write still roll back its retirement.

  • Custody owner reconciliation uses an injected read_custody_owner action instead of the host primary read's filters, preparations or pagination. The resource's base_filter still defines which rows count as existing.

  • A custodian that raises or exits, or an owner that no longer declares a custodian, parks only that disposal obligation with a fixed classification and telemetry. The sweep continues with subsequent references.

  • Unavailable disposal results match the retry attempt they read, preventing delayed sweeps from overwriting newer retry counts or deadlines.

  • IPv6 destination checks now refuse reserved and unallocated address space, including gaps within 2000::/3, using the IANA allocation registry retrieved November 13, 2026. Existing globally reachable special-purpose exceptions and IPv4 classification are preserved.

  • Unrecognized callback reasons become contents-free UnknownError values instead of raising or exposing backend terms.

  • A second key roll inside an active overlap silently dropped the older key from signing. It now returns {:error, :overlap_active} without changing the endpoint. An ended window permits rolling even before the sweep runs.

  • A transport resolver that raises, throws, exits, or returns an invalid value, and a transport setting that is not a resolver, refuse the attempt as a retryable transport_resolution failure instead of falling back to HTTP. Error contents are neither stored nor emitted. Returning nil still selects HTTP.

  • With key_lifecycle :on, outbound signing omits the standard previous key at its retirement instant, even before the sweep removes its reference. Retired references are never resolved. First-use timestamps are written only for keys that signed, with atomic reference checks that prevent a concurrent roll from stamping replacement keys. Undated previous keys keep signing, are skipped by the sweep, and refuse rolling until explicitly scheduled or expired.

Documentation

  • Add the key custody and lifecycle guide, covering host custodians, registry recovery, endpoint and inbound source keys, migration, and subscription pause.
  • Extend the Livebook with real custody conformance, key issuance, signed delivery, rotation and disposal, inbound source resolution and pause, and JSON policy.
  • Add README sections for key custody and lifecycle, inbound sources, pausable subscriptions, and PostgreSQL row security, with links through the tutorials.

3.1.0 - 2026-11-14

Inbound webhooks get an HTTP entry point: AshHooks.Plug takes a request from the router to the ledger and answers it, with no controller code. The minimum supported Ash version increases to 3.37.2 to exclude versions affected by three published advisories. No schema change and no breaking API change; see UPGRADING.md.

Added

  • AshHooks.Plug, an optional generic Plug adapter for inbound HTTP delivery, with endpoint resolution, tenant and scope context, exact raw-body reads, configured public request URIs, and a public default response mapping. refuse: lets hosts shape refusal headers and bodies while preserving status and required headers; retry_after: sets default 503 retry hints (60 seconds by default). signature_header: (or a resolver's :signature_header) names the header whose single value becomes ctx.signature for a provider on the default :header signature source; a missing or repeated header is refused as unsigned.
  • Optional AshHooks.Provider.handshake/1 and AshHooks.Provider.response/1 callbacks for sender challenges and acknowledgment protocols. The plug also accepts a host response policy.
  • AshHooks.BodyReader.put_raw_body/2 and raw_body/1 provide a public exact-byte contract for host endpoint readers and lower-level ingress callers, without a second body read or access to an implementation-specific connection key.

Changed

  • Ash floor raised to 3.37.2 ({:ash, ">= 3.37.2 and < 4.0.0-0"}), so that no admitted Ash release carries a published advisory: EEF-CVE-2026-96581 (HIGH, fixed in 3.37.2), EEF-CVE-2026-114214 (MEDIUM, 3.37.1) and EEF-CVE-2026-101028 (MEDIUM, 3.34.6) all affect releases the 3.0.0 floor (3.34.3) admitted. Increasing the minimum supported dependency version is a minor change; see UPGRADING.md.

Security

  • CI gains a security job that fails closed. OSV's scanner (pinned 2.7.1, checksum-verified) runs offline, with no network, against OSV's Hex database downloaded first, over the development lock and over the lock a consumer resolves at the declared Ash floor; each lock must be exactly what Mix writes, and the scanner must read every :hex and :git entry Mix counts (scripts/check-advisories.sh, with a fixture lock holding both kinds). mix hex.audit fails on a retired package.

Fixed

  • With ingress_tracking :on, the generated :record_rejection action accepted :id even on ledgers without a writable :id attribute (for example one declared with uuid_v7_primary_key), which Ash's accept validation reports at compile time. It now accepts :id only when :ingest does.
  • A verified body that did not decode to a map or list could be rebuilt from its empty placeholder, handled, and marked processed. It is now recorded permanently malformed when written and never handled. Duplicate deliveries still drive the surviving row's stored payload.
  • AshHooks.Delivery.list/2, AshHooks.OutboundAttempt.list/2, AshHooks.Ingress.list/2, and AshHooks.OutboundEvent.list/2 raised on a well-formed cursor whose time was not a string, and returned a query error for a cursor id the resource's id type cannot cast. Both now return {:error, :invalid_cursor}.
  • use AshHooks.Worker accepted a function literal for :transport, which reached the runtime as quoted syntax, so every endpoint silently kept the HTTP adapter. The worker now refuses at compile time any :transport other than nil or {module, function}, and a function literal for :delivery_headers or :certificate_pin. The direct delivery config still accepts functions.
  • Error messages, raised messages, module documentation and code comments no longer use em or en dashes. Each sentence is rewritten in plain punctuation with its meaning unchanged, and a test keeps every shipped document and Elixir source file free of them.
  • Event-log terminal replay forwards its tenant to resend.
  • Missing-row event-log replay binds the declaration and enqueue route, stores the requester, and enqueues the created delivery and event.
  • Health sweeps count and emit disable telemetry only for successful writes.
  • Endpoint health returns {:error, :from_required} for :to without :from.
  • Health sweeps enforce the full warning interval from the stored warning time, including early and overlapping sweeps. The interval is the new auto_disable option warning_interval_seconds (default 60).
  • Delivery pruning checks history deletion and rolls back the batch on failure, keeping history with its delivery.
  • HTTP 410 history retains the request's actual duration and signing-key reference through disable recovery.
  • Synchronous ingestion contains handler exceptions, exits, and throws and records retryable failures.
  • Entry points validate tenancy across every resource they read or write, including optional history and event logs.
  • Worker compilation requires a positive integer delivery_max_attempts.
  • Previous-key retirement records the actual retirement time, including early removal.
  • Health sweeps count and emit warning telemetry only for committed warning markers.
  • Test sends validate optional history tenancy before creating a delivery.
  • Worker compilation rejects fractional job timeout and maximum-backoff budgets.
  • Event-log replay dry runs count the selected batch without creating deliveries.
  • Event-log replay enforces its configured batch rate.

Documentation

  • Previous signing keys remain active until their stored references are removed.
  • Inbound pruning excludes tracked :failed_verification rows.
  • Replay dry runs count a limited batch; skipped rows can appear in repeated calls.
  • Test sends use :signing_mode, defaulting to :standard, without reading subscriptions.
  • Paginated queries require an :id attribute; a full last page still has a cursor.
  • Signature recipes use application-defined headers and signing contracts.
  • Guide examples are compiled and executed from their marked blocks against real databases.

Dependencies

  • Updated the development toolchain and locked dependencies to: Elixir 1.20.5 on Erlang/OTP 29.1.2 (OTP 28 stays in the supported window and the CI matrix), Ash 3.37.4, Spark 2.7.10, AshSqlite 0.3.1 (test substrate), Dialyxir 1.4.9, Makeup 1.2.3. The PostgreSQL leg runs PostgreSQL 18.

3.0.0 - 2026-11-11

Inbound verification becomes generic: describe any sender's signature scheme in configuration, or write one callback with public primitives. The package no longer ships vendor-specific verifiers. Two breaking changes are listed below with their replacements; UPGRADING.md gives the configuration for each removed module. No schema or dependency changes.

Breaking

  • Removed the vendor verifier modules AshHooks.Provider.ComplyCube (and ComplyCube.Event), AshHooks.Provider.HubSpotV3 (and HubSpotV3.Event and decode_request_uri/1), AshHooks.Provider.Twilio, AshHooks.Provider.Stripe, AshHooks.Provider.Shopify, AshHooks.Provider.WooCommerce, AshHooks.Provider.Shippo, AshHooks.Provider.EasyPost, AshHooks.Provider.Magento2, AshHooks.Provider.BigCommerce, AshHooks.Provider.Ecwid, AshHooks.Provider.Squarespace, and AshHooks.Provider.Wix. Replacement: a provider module in your application, usually use AshHooks.Provider, verify: [...] with application-defined verification options. UPGRADING explains the generic replacement and how to preserve existing identities.
  • Removed the name-to-module convention. An inbound declaration without provider no longer resolves AshHooks.Provider.<CamelizedName>; it fails to compile with a message naming the fix. Replacement: set provider on every inbound declaration, keeping the inbound name unchanged so existing deduplication identities still match.

Added

  • use AshHooks.Provider, verify: [...] generates a provider from configuration: HMAC with SHA-1, SHA-256, SHA-384 or SHA-512; RSA PKCS#1 v1.5 and RSA-PSS with SHA-256, SHA-384 or SHA-512; ECDSA P-256 and P-384 with DER or raw r || s signatures; Ed25519; and compact JWS bodies with the algorithm pinned by the host. Signatures come from a named header (optionally prefixed), a structured header of key/value pairs carrying up to 16 signatures, or the body. Hex, base64 and base64url encodings; raw, hex or base64 secrets with an optional prefix; PEM public keys, X.509 certificates or raw Ed25519 keys; a signed input built from the body, timestamp, method, URL, path, headers and literals, or by a host function; timestamps in seconds or milliseconds from a header, a signature field or a host function, with a symmetric tolerance. Options are checked at compile time and every generated callback can be overridden.
  • AshHooks.Provider.Scheme documents those options. new!/1 validates them, verify/4 verifies with them directly, and payload_identity/1, decode_payload/2, timestamp_header/1 and signature_source/1 back the generated callbacks.
  • A provider configured with signature: :jws_body also gets decode_payload/1, which stores the verified JWS payload, and event_identity/1, which deduplicates on the SHA-256 of that payload as canonical JSON (AshHooks.Provider.Scheme.payload_identity/1) instead of the raw-body digest. Two encodings of the same signed content share one ledger row.
  • AshHooks.Provider.Signature.jws/3 and :jws_body accept only unpadded base64url segments, as RFC 7515 requires. A token that contains = fails with :invalid_signature.
  • AshHooks.Provider.Signature is public: hmac/4, rsa/4, ecdsa/4, ed25519/4, jws/3, compare/2, header/2 and check_timestamp/3, for providers that implement verify_signature/3 themselves.
  • The optional signature_source/0 callback accepts :request, for providers that read their own signature from the request headers; ingress then needs no ctx.signature.
  • AshHooks.Ingress.ingest/4 accepts the request headers as an ordered list of {name, value} pairs, such as conn.req_headers, as well as a map. Providers receive every line in arrival order in the new ctx.header_list, and repeated lines are joined with ", " in ctx.headers. A map the host passes is delivered unchanged, as before.
  • AshHooks.Provider.Hmac accepts :sha384 and :sha512 algorithms.
  • A "Verify any sender" guide with recipes for common signature shapes.

Changed

  • AshHooks.Ingress.ingest/4 fails verification when headers is neither a map nor a list of binary {name, value} pairs. A list reaches providers as a map in ctx.headers and in full in ctx.header_list.

2.3.0 - 2026-11-11

Added

  • Inbound routes can accept application/x-www-form-urlencoded bodies: declare body_format :form on the route, or return it from a provider's optional body_format/0. Signatures are verified over the exact raw bytes before decoding; JSON stays the default. Providers can decode a signed body envelope after verification. Invalid UTF-8 fields are recorded as a permanent malformed payload.
  • 2.3.0 added verifier modules for Twilio, Stripe, Shopify, WooCommerce, Shippo, Adobe Commerce/Magento 2, BigCommerce, Ecwid, Squarespace, and Wix. 3.0.0 removed those modules.
  • 2.3.0 added the former AshHooks.Provider.EasyPost module. 3.0.0 removed it.
  • 2.3.0 extended the former EasyPost verifier. That module was removed in 3.0.0.
  • A host-configured HMAC verifier for emitter-defined contracts: header name, SHA-256/SHA-1, hex/base64, optional signed timestamp and tolerance, canonical input, and overlap keys, for application-defined signing contracts.
  • Optional outbound retry-status selection, preserving current defaults and the existing success, redirect, and 410 rules.
  • Optional outbound host headers resolved per delivery, with case-insensitive protection for signing, content-type, and framing headers.
  • Optional exact certificate, certificate SHA-256, or SPKI SHA-256 pins on the bounded HTTP adapter, selected per endpoint or host configuration. Normal TLS checks remain required. Pin failure closes before sending and does not retry.

Fixed

  • Tenant-aware one-argument inbound paused and previous_secret sources receive the resolved tenant and take effect on multitenant ledgers. Tenant-less, zero-argument, {module, function, args} and app-env sources behave as before.
  • Previous-secret app-env sources resolve the documented binary keys while preserving the legacy {:ok, key} value shape.

No new dependencies or schema changes.

2.2.1 - 2026-11-08

Fixed

  • A sustained-failure disable now always follows an earlier WARNING sweep. In 2.2.0, the first AshHooks.EndpointHealth.sweep/3 that saw an endpoint already meeting the disable thresholds (failure_share + min_attempts) disabled it immediately; the [:ash_hooks, :endpoint, :disable_warning] the moduledoc promised never fired, and the notify surface got no chance to reach anyone before the breaker opened. The warned state is now durable: declaring auto_disable injects the disable_warned_at marker column (migrate it with the declaration), the first qualifying sweep warns and stamps, and the disable lands on the next sweep that still qualifies, clearing the stamp. Recovery below the warning band clears the stamp, so a later degradation gets a fresh warning cycle.

2.2.0 - 2026-11-08

A minor under the public support policy: everything new is additive opt-in surface; no existing column, action, default, or event changes shape. Adopt what you need; each block names its DSL declaration and migration. Read UPGRADING.md before adopting.

Added

  • Attempt history. The new AshHooks.OutboundAttempt extension turns a consumer resource into the per-attempt audit ledger: one durable row per delivery attempt (time, outcome, classified reason, HTTP status, latency in milliseconds, and the signing key REFERENCE, never secret material), written by the runtime beside its fenced result transitions and idempotent per (delivery, attempt). Latency is the request's duration, recorded with the signing-key reference for each attempted request (including one that failed at transport, at destination pinning, or in a crashing adapter). Both are nil when no request was made (destination-policy refusal, DNS failure at the send gate, secret resolution) and when an HTTP 410 disable obligation stored without attempt history is finalized. Wire it with attempts: on the worker macro or the direct-run config. A history write failure never fails the send; it surfaces as [:ash_hooks, :attempt, :record_failed] telemetry.

  • Per-endpoint response capture. response_capture_attributes :on on the endpoint resource injects per-row capture columns; an endpoint that sets response_capture: true records bounded (response_capture_max_bytes), redacted response bodies and only response_header_allowlist-named response headers in its attempt rows. Capture stays off by default everywhere.

  • Delivery-log queries. AshHooks.Delivery.list/2 and AshHooks.OutboundAttempt.list/2: filter by endpoint, status/outcome, event type, and time range with keyset pagination (newest-first, (time, id) cursors), tenant pre-flighted like every package entry point.

  • Test events. AshHooks.Delivery.test_send/2 sends one signed synthetic test event of a chosen type to ONE endpoint, OUTSIDE subscriptions; no subscription row is consulted, and the delivery lands in the ledger like any other. Each send carries a fresh msg_ id (never dedup-suppressed), the chosen type verbatim, and a self-marking default payload ({"test": true, "type": ..., "timestamp": ...}; a caller-supplied payload is used verbatim). Emits [:ash_hooks, :delivery, :test] beside the normal lifecycle, drives the row synchronously (default one attempt), requires a live endpoint, and returns {:ok, %{status:, delivery:}}.

  • The finishing details. Test sends are now FLAGGED end to end: test_tracking :on on the delivery ledger injects the test column, AshHooks.Delivery.test_send/2 rows carry test: true, attempt history rows flag themselves, and both list queries filter on test:; test sends appear in the delivery log, clearly marked. The per-delivery diagnostic capture (snippet_capture: true) rides every driver call including test sends, beside the per-endpoint setting. Catalog entries carry an example payload. Health stats report FIRST-ATTEMPT successes separately from EVENTUAL successes (and the delivery count). Attempt history prunes WITH its delivery rows (prune/2's :attempts option). And a test send can target the transport; a CLI "listen" command's trigger arrives as a signed, test-marked payload on the developer's forwarder.

  • Inbound parity. AshHooks.Ingress.list/2 queries inbound deliveries by source, status, event type, and time range with keyset pagination; counts/2 answers the window's story (received, duplicates ignored, failed verifications, handler failures) with ingress_tracking :on on the ledger (the duplicates counter column and payload-less :failed_verification rejection rows, digest identity). The inbound DSL's previous_secret source rotates a source with an overlap window (both keys verify until the option is removed), and paused (any secret-source shape resolving a boolean) refuses every request with {:error, :source_paused}; answer 5xx so the sender may retry. Paused requests are not stored, and recovery depends on that sender's retry policy.

  • Tenancy across the new surface. Every new entry point (attempt history reads and writes, delivery-log queries, resend and replay, test sends, health stats and the disable sweep, key rolling and expiry, the event log's list/prune/replay) takes :tenant, resolves the tenancy pre-flight first, and fails closed with {:error, :tenant_required} on multitenant resources without one. Multitenant attempt tables carry the tenant-partitioned unique_attempt index (the delivery ledger's pattern); AshHooks.Endpoint.expire_previous_secret/2 gained its :tenant option.

  • The event log. The new AshHooks.OutboundEvent extension records each dispatched event ONCE (id, type, declared payload version, time, and exact payload bytes), whether or not any endpoint was enabled (wire it with events: on the outbound declaration). The log is idempotent on the event id; a failed log write never stops the fanout ([:ash_hooks, :event, :record_failed]). Its own retention (AshHooks.OutboundEvent.prune/2), keyset queries by type and time range (list/2), and replay: AshHooks.OutboundEvent.replay/3 sends one event or a filtered set to a CHOSEN endpoint (including one that was off at the time or added later), keeping the event id (receivers dedup), re-arming terminal rows through resend, and recording who asked everywhere.

  • The delivery transport behavior. AshHooks.Transport is the behavior for routing ONE endpoint's deliveries to your own transport (a developer's local forwarder behind a CLI "listen" command, for example) instead of HTTP: an adapter-shaped request/5 receiving the SAME signed request the wire would, with the runtime's attempts, attempt history, classification, backoff, and telemetry applying unchanged. Route per endpoint with transport: {module, function} (worker option or direct-run config; the direct-run config also accepts a 2-arity function) returning the transport module or nil to keep the HTTP adapter; a routed endpoint skips the packaged send-time destination gate (the transport owns destination semantics), and a crashing resolver or non-module return falls back to HTTP contained.

  • Subscription filters on declared event attributes. The subscription DSL's filter_attributes([:order_id, :region]) declares the closed set of attribute names subscriptions may filter on and injects the event_filters column (:map): a subscription whose filters all equal the dispatching event's metadata values receives the delivery; multiple filters AND together, a list value matches any-of. Filters are evaluated in the dispatcher before any delivery row is created. A filter with an undeclared key or a malformed value never matches; filtering fails closed. Attribute values ride the event's metadata.

  • The event catalog and payload-version pinning. The outbound DSL declares each event type's metadata: description, payload_schema (any term your docs renderer understands), version (default 1), and optional payload_versions (a map of version => {module, function} variant builders). Read it back through AshHooks.Catalog.entries/1 and entry/2 for event pickers and doc generation. Declaring version_pinning :on on the endpoint resource injects pinned_payload_version. Endpoints without a pin, or pinned to the declaration's current version, receive the dispatch payload; other pins receive the matching payload_versions builder's exact bytes (per-endpoint rows carry their own bytes). A pin on a version with no builder, or a failing or crashing builder, fails that endpoint closed before any row is written; the fanout continues.

  • Endpoint health and sustained-failure auto-disable. AshHooks.EndpointHealth.stats/2 computes one endpoint's trailing-window health from its attempt history: success rate and nearest-rank latency percentiles (p50/p90/p99 ms). The new auto_disable section on the endpoint resource declares the policy beside the existing 410 rule (failure_window_seconds, failure_share, min_attempts, and warning thresholds); AshHooks.EndpointHealth.sweep/3 disables an endpoint whose window meets the share with the minimum evidence (through the same durable switch the 410 rule uses) and emits [:ash_hooks, :endpoint, :disable_warning] BEFORE it disables; the notify surface gets its chance at the warning thresholds. Re-enabling stays an explicit application action.

  • Secret rolling with an overlap window. key_lifecycle :on on the endpoint resource injects the six signing-key lifecycle columns (created / first-used / retired for the current key and its predecessor, all timestamps and never secret material) and unlocks AshHooks.Endpoint.roll_secret/2: the incumbent reference moves to previous_secret_ref (the Standard Webhooks zero-downtime seam: deliveries carry both keys' signatures until the previous reference is removed; the overlap deadline makes it eligible for removal by expire_previous_secrets/2, and reaching the deadline alone does not stop its use), the new reference takes its place, and the old key's retirement is scheduled (:overlap_seconds, default 24h). expire_previous_secrets/2 is the scheduled sweep; expire_previous_secret/1 retires at once on request. The delivery runtime stamps each key's first use at signing time (nil-gated, only on lifecycle resources).

  • Resend and bulk replay. AshHooks.Delivery.resend/2 re-arms one terminal delivery row (:succeeded/:dead_letter) with the SAME event id (a Standard Webhooks receiver deduplicates the repeat POST), while the lifetime attempt counter keeps climbing (attempt-history rows stay unique) and a fresh retry ladder starts at resend_baseline. AshHooks.Delivery.replay/2 re-arms a filtered set (endpoint, event type, status list, time range) with dry_run: true counting matches and :per_second/:limit bounding the rate. Both record who asked (last_resend_by/last_resend_at, resend_count), refuse anything but live endpoints ({:error, :endpoint_not_live} / counted skips), and require the new resend_tracking :on DSL (four migrated columns); existing schemas are untouched. Every re-arm emits [:ash_hooks, :delivery, :resend].

  • A public send-time destination policy seam. AshHooks.DestinationPolicy is the supported way to carry your own allow and deny rules without forking the packaged SSRF check: a {module, function} callback (worker option :destination_policy, or the same key in a direct AshHooks.Delivery.run/2 config) receives the endpoint's URL and a %{endpoint_id:, tenant:} context and decides :allow (skip the packaged gate; pair it with the HTTP adapter's validation override for destinations that check would refuse), :deny (terminal destination_denied), or :default (the packaged tri-state check runs unchanged). A callback that crashes or returns a term outside the vocabulary is contained as a retryable destination_policy_failed; a policy defect never dead-letters deliveries. A configured policy takes precedence over the boolean :ssrf_check seam; with no policy configured, behavior is unchanged.

  • Runtime-configurable worker timing. use AshHooks.Worker accepts runtime_config: {module, function}; the callback receives the Oban job's args (tenant included) on every perform and returns a keyword of overrides for :delivery_max_attempts, :base_backoff_seconds, :max_backoff_seconds, :retry_after_cap_seconds, :attempt_timeout, and :finalization_allowance, merged over the compiled defaults. Every compiled-budget misfit check re-runs at runtime against the resolved set (positive integers, backoff ordering, the baked Oban job-timeout envelope including a literal http_opts timeout: collision, and the Oban-ceiling relation, since only the row ceiling may decide dead-letter): a violation fails the job with {:error, {:invalid_runtime_config, reason}} before any delivery work, leaves the row untouched, and emits [:ash_hooks, :worker, :invalid_runtime_config] (the reason vocabulary is fixed; a contained callback crash is callback_failed). The public resolver AshHooks.Worker.resolve_config/2 backs the seam.

2.1.0 - 2026-11-01

A minor under the public support policy, not a patch: AshHooks.Ssrf.resolve_public/1 is covered surface and its documented DNS-failure vocabulary changed (:unresolvable → :nxdomain | :resolve_timeout), and use AshHooks.Worker now refuses previously-compiling misfit configurations at compile time. No schema, DSL, or success-path change; read UPGRADING.md before adopting.

Fixed

  • Unresolvable DNS is transport, not a verdict on the destination. The default send-time destination check now runs the tri-state AshHooks.Ssrf.resolve_public/1 instead of the boolean safe_url?/1, which folded unresolvable into unsafe: a resolver outage (or mere congestion past the two-second resolution ceiling) permanently dead-lettered healthy endpoints at attempts == 1 under the unsafe_destination label, while the same condition surfacing one layer later (inside the HTTP adapter) retried as transport. Now a validated-unsafe answer still dead-letters immediately as unsafe_destination; an unresolvable host retries under its honest label: nxdomain when every queried address family answered authoritatively negative, resolve_timeout for an outage, congestion, or mixed evidence (both in the telemetry reason vocabulary; nxdomain had sat unused there), and a permanently dead domain dead-letters at the row ceiling carrying that label. The HTTP adapter's umbrella atom for the same failures is unresolved_host (also newly in the vocabulary, as it previously collapsed to unclassified). Consumer-observable: rows that would have been terminal at attempts == 1 now climb the backoff ladder; consumers branching on an immediate unsafe_destination for DNS-dark endpoints see failed_retryable/nxdomain/resolve_timeout rows instead. The injected :ssrf_check boolean seam is unchanged (false still dead-letters as unsafe_destination).
  • Compiled worker-budget tripwires. use AshHooks.Worker now refuses, at compile time, related budgets whose silent misfit stalls rows or walls off every slow send: Oban's :max_attempts must exceed :delivery_max_attempts (error-class results, such as attempt timeout, driver crash, and endpoint read errors, consume Oban executions in step with row attempts while snooze-class results consume none, so only the row ceiling may decide dead-letter; a larger row ceiling against the default Oban ceiling truncated the retry ladder mid-flight and stalled rows until a recovery trigger), a literal :http_opts timeout: must stay below :attempt_timeout (the runtime kills the attempt at the budget wall before the driver's own deadline), the macro validates positive attempt, finalization, base-backoff, and Retry-After budgets, and :max_backoff_seconds must be at least :base_backoff_seconds. A literal :http_opts validate_destination: false (the test seam for loopback listeners) now refuses to compile outside :test (with it baked in, the driver's send-time check would be the only remaining SSRF layer; an {m, f, a} bundle resolves per-perform and cannot be compile-checked). Previously-compiling misfits now raise ArgumentError at compile.

Docs

  • The :http_opts option of AshHooks.Worker now states its trust posture: validate_destination: false (the test seam loopback listeners use) disables the adapter's resolve-and-pin defense, is refused at compile outside :test, and must never ship to production. The AshHooks.Delivery classification table gains the unresolvable-DNS row.
  • The send-time SSRF classification is now pinned end-to-end with real DNS through the package's own driver: a registration-clean hostname whose send-time answer is private is refused by AshHooks.Http.Bounded's resolve-and-pin and dead-letters through the runtime (no injected refusal, no validate_destination bypass). Checks also cover the driver-side unresolvable arm and the default-check arms for both classes.

Dependencies

  • Update locked dependencies to remove the published advisories affecting the previous lock (the shipped requirement lines are unchanged; the declared Ash floor stays >= 3.34.3 and the floor qualification still pins it): ash 3.34.6 → 3.37.2 (EEF-CVE-2026-96581 HIGH, EEF-CVE-2026-114214 MEDIUM), ash_postgres 2.14.5 → 2.15.2 (EEF-CVE-2026-115627, EEF-CVE-2026-115635, plus the retired-package notice), plug_crypto 2.2.0 → 2.2.1 (EEF-CVE-2026-105963), and the dependency updates igniter 0.8.5, oban 2.24.2, spark 2.7.9, splode 0.3.3 (with their transitive closure). mix hex.audit and scripts/check-currency.sh are clean against the new lock.

2.0.4 - 2026-10-09

Fixed

  • Generated Oban workers no longer report Dialyzer pattern-match warnings for unsaved uniqueness conflicts. Oban's job type declares a persisted ID but its Basic engine can return an unsaved conflict; admission reads the ID through a private map helper. Retry limits, not-persisted refusals, identity checks, and runnable-state checks retain their behavior.
  • The type gate now compiles the same generated worker used by the PostgreSQL suite. Real Oban.Basic transaction tests force an unsaved conflict, verify retry after the winning transaction commits, and verify refusal after all twenty retries.
  • Dependency updates: Ash 3.34.4 → 3.34.6 (resolves EEF-CVE-2026-101028 in the locked graph) and AshPostgres 2.14.3 → 2.14.5.

2.0.3 - 2026-10-07

Fixed

  • Delivery diagnostics survive recovery races, end to end. Re-admission no longer wipes last_error: a successful release after a durable enqueue replays the row's admission-time diagnostic (the story of the failure that scheduled the retry: http_503 stays visible through the retry; only a fresh enqueue failure writes a new error). Every outcome that resolves the row's immediate fate (mark_succeeded, mark_send_failed (both the terminal and the retryable form), finalize_disable, and the stored 410 obligation itself (mark_disable_pending)) now RELEASES the enqueue claim in the same statement, so a reconciler whose enqueue raced the outcome finds the token gone. A release that then matches zero rows on a cleared claim classifies as BENIGN COMPLETION (:reconciled, never :endpoint_error); only a still-live foreign claim is a genuine :stale_enqueue_claim. And a successful release now PARKS the enqueue lease for one horizon (30s): a concurrent recovery sweep can no longer re-admit the row in the instant between the token clearing and the sweep ending; admission is exactly-once per recovery window at the seam itself (the concurrent-reconciler contract the suite pins, previously upheld only by SQLite's statement serialization; the final coverage gate caught the true-concurrency gap). The :release_enqueue machine primitive gains an optional enqueue_lease_expires_at argument (default nil, with no change for direct callers). Consumer-observable consequence: a recovery sweep that runs inside a freshly admitted row's 30-second parked-lease horizon now reports that row as a contended :duplicate where 2.0.2 re-admitted it; sub-30s recovery cadences and :duplicate-count alerting will see the new shape. A row whose release reload finds it deleted or unreadable now reports :enqueue_reload_failed instead of a stale-claim error. Regression tests reproduce the recovery races on SQLite and PostgreSQL.
  • Test: the 5xx backoff bound is asserted exactly (4..7); the legacy <= 8 accepted an unreachable value.

2.0.2 - 2026-10-07

Fixed

  • Outbound Retry-After is honored on every retryable status, not only 408/429: a 5xx response carrying the header (the canonical 503 overload signal) now schedules the receiver's own recovery window; an absent or malformed header keeps the backoff fallback. Note the bound this moves: a header-bearing 5xx snooze is clamped by retry_after_cap_seconds (default 86,400s), not max_backoff_seconds (default 3,600s); if you shortened max_backoff_seconds to finish retries sooner, also lower retry_after_cap_seconds.
  • Test dependency updates: ash_postgres 2.14.2 → 2.14.3.

2.0.1 - 2026-10-06

Version 2.0.1 includes the delivery ownership, recovery, and migration changes below. The guided tour keeps protocol implementations available for resources defined during notebook evaluation.

Fixed

  • Disable protocol consolidation in the Livebook setup so dynamically defined Ash resources use their custom display without consolidation warnings.
  • Update the notebook and release tooling to 2.0.1.

2.0.0 - 2026-10-06

The changes below first shipped in 2.0.1.

Delivery rows now retain declaration and queue ownership, fence each send attempt, and recover unfinished work after queue exhaustion or an interrupted endpoint disable. The former AshHooks.Provider.HubSpotV3 module used a stable batch identity for retries. The default transport bounds the complete HTTP operation. Existing installations require the ordered schema and identity migration in UPGRADING.md before running 2.0.1 workers or ingress.

Changed

  • Outbound rows persist declaration ownership and queue route. A declaration cannot recover another declaration's rows. Named callbacks have stable routes; anonymous callbacks can supply enqueue_key for durable recovery.
  • Send and recovery admission use separate UUID tokens and expiring leases. Every result is fenced to the live attempt; retry ceilings are checked before sending. The complete ledger primary key is used throughout.
  • A 410 response records :disable_pending before disabling the matching endpoint configuration. Recovery completes that obligation without another HTTP request.
  • Oban uniqueness covers runnable jobs and the durable route/tenant identity. Completed or discarded jobs do not strand recoverable rows; an unpersisted conflict is an admission error.
  • The former AshHooks.Provider.HubSpotV3 module changed its default deduplication identity to canonicalize the batch while excluding each outer event's attemptNumber. The optional provider event_identity/1 callback follows an explicit declaration extractor in precedence. Retained legacy rows are adopted explicitly, preserving payloads and an audit map.
  • Ash's supported floor is 3.34.3, including its security correction and the tenant inverse API used by workers. The lock resolves Ash 3.34.4, AshPostgres 2.14.2, and Spark 2.7.6.

Fixed

  • Minimal production consumers start :public_key and :ssl through the package's application dependencies; optional packages are unnecessary for default HTTPS.
  • Direct delivery calls apply the documented retry defaults for omitted or nil settings, including the attempt ceiling and bounded Retry-After, without requiring an Oban worker.
  • Required keyset pagination, bounded retention deletion, custom ledger keys, renamed UUID endpoint/subscription keys, and aliased worker HTTP-option resolvers.
  • Endpoint status values are cast and constrained at compile time; empty enabled sets, overlapping states, and primary-key mappings are rejected.
  • IDs on direct event structs and HTTP headers reject control bytes and malformed UTF-8. Telemetry reasons use a fixed vocabulary, preventing arbitrary tokens from escaping.
  • SSRF classification covers special-purpose address ranges; IPv6 Host values are bracketed. Bounded HTTP follows interim responses to the final response, stops at its body cap, and uses one deadline across resolution and transport.
  • The former AshHooks.Provider.HubSpotV3.Event mapping gained generic object events.

Documentation and delivery

  • Current install/version pins, terminal inbound acknowledgments, generated DSL references, migration instructions, and an executable 2.0.1 Livebook.
  • Package archive inspection and notebook execution precede publication; the normal notebook then executes against the exact published version.
  • Documentation changes trigger Linux CI. The minimum-consumer leg pins Ash 3.34.3; package, PostgreSQL, coverage, and Livebook checks feed all-checks-pass.

1.3.0 - 2026-10-05

Additive options for domain naming and lifecycle, a compile fix for generated (non-writable) primary keys, typed subscription matching, loud documentation of the policy/id/adapter obligations, and a Linux CI leg exercising an AshPostgres uuid_v7 consumer shape.

Added

  • payload_attribute on the outbound_delivery section. The exact payload-bytes column's name is configurable (default :payload): rename it when the consumer's domain reserves payload for its own sole payload store. The injected column, the :dispatch accept list, and every signing/sending read follow the configured name; a name colliding with another injected field fails closed at compile.
  • prune_action :none on the outbound_delivery section. Opt out of the retention destroy :prune action's injection for append-only audit ledgers (no destroy action exists on the resource at all); AshHooks.Delivery.prune/2 then fails loud with a named error; deletion is the consumer's own surface. Default :destroy is unchanged.
  • status_attribute / enabled_values / disabled_value on the new endpoint section. Map the durable enable/disable onto the consumer's OWN switch (e.g. an active boolean): status is then not injected. There is one switch, so the consumer's off switch and the package's can never silently disagree. The dispatcher's skip and the send path's dead-letter both route through AshHooks.Endpoint.enabled?/1; the 410 auto-disable flips the mapped attribute. The mapped attribute must be consumer-declared (fail-closed at compile).
  • A Linux CI leg with a Postgres service exercising the transformers against an AshPostgres, uuid_v7-keyed, sole-store-payload consumer shape (postgres job; the suite is env-gated by ASH_HOOKS_POSTGRES=1 and excluded from ordinary dev runs). ash_postgres is a dev/test-only dependency; it never ships or constrains consumers.

Fixed

  • :dispatch/:ingest no longer accept :id on resources whose primary key is a non-writable :id (e.g. uuid_v7_primary_key): Ash's ValidateAccept raised at compile on exactly that consumer shape, making the extensions unadoptable without replacing the PK. The accept lists carry :id only when the PK is a writable :id (the package-injected default, with byte-identical classification); the transformer's decision is persisted and the runtimes read it back, so the compiled action and the classification path can never disagree (composite and non-:id primary keys included). For the non-writable shape, created/duplicate classification pre-reads the unique identity instead: exact in every sequential case (provider redeliveries, producer re-fires) and wherever the primary read can see the existing row (a base-filtered read that hides it classifies :created). Under a misclassification the storage upsert preserves one row. A double send stays impossible through the mark_sending CAS and inbound claim fence. Correction first shipped in 2.0.1: the 1.3.0 outbound state transition did not fence every late result or expired owner. Version 2.0.1 adds attempt tokens, leases, and separate enqueue claims; network sends remain at-least-once and require receiver deduplication. In 1.3.0 the enqueue seam was the configured enqueuer's own fence: the default Oban enqueuer's endpoint_id+event_uuid job uniqueness, or the consumer's own dedup for a custom enqueue:. Public support policy note: the injected action accept lists are covered surface; this is a behavior correction (the previous accept list required a writable PK that consumers with generated PKs cannot provide), not a removal; no working consumer can regress (the shape did not compile).
  • With the endpoint status mapping, the send path dead-letters an endpoint whose status is anything other than :enabled (previously only an exact :disabled dead-lettered, so a consumer-redeclared status with extra values delivered). The dispatcher's skip and the send path now route through the ONE AshHooks.Endpoint.enabled?/1 check, which fails closed by design.
  • AshHooks.Subscription.matches?/2 normalizes event_types entries with to_string/1. An atom-typed register ({:array, :atom}, a closed enum) previously matched NOTHING: zero deliveries, no error. Atom and string entries (and the "*"/:"*" wildcard in either representation) now match identically. Consumers redeclaring event_types keep their own constraints; the injected ["*"] default is not forced on them.

Changed

  • CI is Linux-only; the macOS and Windows build legs are removed. At this release, CI moved to Linux only. Current development supports macOS, Linux, and Windows through WSL2. The README no longer claims dedicated per-OS legs. Also hygiene: the workflow's pinned GitHub Actions (checkout, cache, upload-artifact) moved off the Node 20 runtime to their current releases. No library code changed.
  • The DSL documentation check now fails when generated reference files are stale. The package leg's mix spark.cheat_sheets --check ran without an extension list and checked nothing; it now passes the five extensions explicitly, so a stale documentation/dsls/ actually fails the build (the sheets in this release are regenerated under that invocation).
  • Dev/test mint bumped 1.10.1 → 1.11.0 (EEF-CVE-2026-94194 / -91043 / -92103, via the dev-only igniter→req→finch tree; never ships in the package). ash_postgres 2.13.1 is added dev/test-only for the Postgres leg above.

Docs

  • Policy obligation at the extension site (OutboundDelivery, Endpoint moduledocs): the injected write actions are named and the consumer-owned policy obligation is stated loudly, mirroring the inbound half's "you write your own" posture outbound. This covers the seven delivery write actions and the endpoint's :disable action.
  • Deterministic Event.id guidance (Event, Dispatcher moduledocs): derive the id from the artifact's stable id; a generated id turns every producer re-fire into a duplicate POST per sweep.
  • The adapter-author contract (AshHooks.Http moduledoc): headers must be a LIST of {name, value} tuples (a map silently loses Retry-After), and the resolve-once/connect-pinned obligation that closes the DNS-rebinding TOCTOU is the adapter's, with the driver's send-time check as the residual.
  • retry_after_cap_seconds semantics (Worker moduledoc): the default Retry-After cap allows a receiver to delay each attempt by up to 24 hours. Lower the cap if your application requires a shorter retry period.
  • The 410 auto-disable posture (Delivery moduledoc): an unattributed system bulk write by design (no actor in a versioned register), with no built-in tenant-facing signal. A receiver that answers 410 once goes dark silently unless the app wires the [:ash_hooks, :delivery, :disable] telemetry event or accepts the posture in writing.

1.2.1 - 2026-09-24

Fixed

  • The documentation tree now ships in the hex tarball. 1.2.0's package carried only the top-level docs (README, CHANGELOG, UPGRADING, usage-rules), so documentation/ (including the multi-tenant adoption checklist) was reachable only on GitHub/hexdocs while UPGRADING.md and the CHANGELOG referenced it by repo-relative path. Installed-package readers now get the tutorials (get-started, tenancy-adoption-checklist), the DSL reference, and the Livebook alongside those references. No library code changed; hexdocs and the package page README are unaffected.

1.2.0 - 2026-09-24

Tenancy release: ash_hooks aligns with Ash attribute multitenancy. An explicit tenant threads every data call, and the package fails closed with named errors before any data access when a multitenant resource is touched without one. Single-tenant adopters change nothing: the entire suite from versions before 1.2.0 passes unchanged over tenant-less fixtures inside the now-610-test gate, because threading a tenant through resources with no multitenancy declaration is mechanically inert.

Added

  • Tenant threading on every path: AshHooks.dispatch/4 (:tenant opt), AshHooks.Ingress.ingest/4 (ctx[:tenant]), the claim/mark/ renew/redact/prune/reap heads (:tenant opt, new optional arity), AshHooks.Delivery.run/2 (tenant recovered from job args), and both prunes. The tenancy contract: consumers declare multitenancy :attribute, attribute: <same attr> on the resources a given operation touches; the package verifies that set on every entry point and returns {:error, :tenant_required} / {:error, :tenancy_mismatch} before any data access (Ash's native fail-closed stays the backstop; global?: true is rejected; it silently disables fail-closed reads). A compile-time verifier additionally rejects multitenancy :bypass, :bypass_all, and :allow_global actions on multitenant package resources.
  • Per-tenant operations: AshHooks.reap_all/2 and AshHooks.prune_all/2 sweep a tenant enumerable sequentially with per-tenant error isolation and totals ({:ok, %{results: %{tenant => {:ok, n} | {:error, reason}}, total: n}}).
  • AshHooks.reconcile_pending/3: the supported reconciliation for delivery rows stranded at :pending by a crash between row write and enqueue: a WHERE-gated CAS flip to :enqueue_failed (a real state change, where matched-records is the win signal and exactly one reconciler wins per row, proven under a custom non-Oban seam), then enqueue through the same seam dispatch takes. Exactly-once ACROSS claim mechanisms (reconciliation vs re-dispatch repair) is the enqueue seam's contract: the canonical Oban seam's job uniqueness provides it; a custom seam must be idempotent itself.
  • Tenant-aware secret resolution (all optional): the worker macro's :tenant_aware_secrets (2-arity f(ref, tenant) resolver contract); the inbound secret fn tenant -> ... end source; the provider behavior's optional webhook_signing_secret/2 (per-tenant secret custody; use AshHooks.Provider ships an overridable default delegating to /1); and :tenant in the verify_signature/3 context map.
  • Oban args carry the tenant: the generated enqueue/2 serializes the row's tenant. Strings and integers survive JSON unchanged; atoms arrive as strings. Pair a custom parse_attribute with tenant_from_attribute so the stored attribute and job tenant round-trip. In 1.2.0, uniqueness keys stayed [:endpoint_id, :event_uuid], and a pre-tenancy tenant-less job still conflicts with the tenant-bearing job on the same pair (proven on the real Oban engine).
  • The dispatch result contract is now a public typespec (AshHooks.Dispatcher.dispatch_result/0) including the new :reconciled status.
  • The multi-tenant adoption checklist (documentation/tutorials/tenancy-adoption-checklist.md) and the public support policy.

Migration notes

Two adopter classes see action; single-tenant staying single-tenant sees none. See UPGRADING.md and the adoption checklist: (1) cutover with in-flight Oban jobs created before 1.2.0: drain before serving multitenant dispatch (pre-tenancy args fail closed, correct but noisy); (2) single→multi on populated tables: backfill the tenant attribute first (NULL-tenant rows form a shadow partition that strands effect-once), then regenerate identity indexes, then enable.

1.1.1 - 2026-09-16

This release added portability tests for macOS, Linux, and Windows. It did not change the public API. The package added tests for platform support; a dedicated CI leg per OS runs the full 555-test suite on the dev-default toolchain, all nine legs green, and the README claims exactly the OSes the legs prove.

Added

  • CI legs on macOS and Windows (dev-default toolchain Elixir 1.20.4 / OTP 28, compile --warnings-as-errors + the full suite). Linux was already proven by every existing leg.
  • .gitattributes (* text=auto eol=lf): every OS checks out byte-identical sources; all tracked files were already LF, so no renormalization was needed.

Fixed

  • Four test-side portability defects exposed by the first Windows run (the package and its sqlite NIF substrate compiled and ran on Windows throughout; every defect was in fixtures):
    • two :inets httpd fixtures hardcoded server_root: "/tmp", nonexistent on Windows; one failure hid as a setup_all invalidation that silently excludes a whole module's tests from the failed count; both now use System.tmp_dir!();
    • CRLF checkout on Windows broke the install-task fixture's byte assertions (=~ "plug Plug.Parsers\n" vs "\r\n" bytes);
    • httpd's URL→path translation mangles backslashes, so every request returned 500 on Windows; the fixtures now hand httpd forward-slash server_root/document_root (a no-op on unix).

1.1.0 - 2026-09-16

Support-window release: the Elixir floor rises to 1.20 (a minor, not a major, by the public support policy, in the first exercise of that rule), the repo's own toolchain becomes self-enforcing and lockstep-pinned, and locked Oban is updated to 2.24.1, Dialyxir to 1.4.8, and ExDoc to 0.40.4, with mix hex.audit running in CI.

Changed

  • The supported Elixir window is now ~> 1.20 (was ~> 1.17); nothing below Elixir 1.20 is supported; the OTP floor is 28 (CI tests 28 and 29). Consumers on 1.17 to 1.19 get a resolver-level refusal instead of a compile. The public support policy makes a supported-floor bump a MINOR release, so a ~> 1.0 pin resolves 1.1.0 and then fails resolution on old Elixirs. Pin {:ash_hooks, "~> 1.0.4"} until you can move (see UPGRADING.md). CI tests the window on Erlang/OTP 28 (the dev default, pinned in .tool-versions and mirrored by a dedicated leg) and 29; the floor leg drops the lock and resolves at the floor to keep the requirement honest.
  • Repo-local toolchain enforcement. Consumers are unaffected: config/ is excluded from the hex tarball. Development runs on one pinned toolchain (.tool-versions: Elixir 1.20.4 / Erlang/OTP 28) mirrored by a dedicated CI leg; config/config.exs refuses any OTP release CI does not test (currently 28/29) before anything compiles, because System.version/0 does not encode the OTP build and a same-Elixir foreign build would otherwise compile incompatible BEAMs silently. The window, .tool-versions, the OTP allowlist, and the CI matrix move together in ONE commit. mix hex.audit now runs in CI on every push.
  • Updated locked dependencies: Oban 2.23.1 → 2.24.1, Dialyxir 1.4.7 → 1.4.8, ExDoc 0.40.3 → 0.40.4. mix hex.audit clean before and after (and OSV shows no advisories against the three new versions).

Fixed

  • A %Regex{} inside a module attribute (@redaction_patterns) embeds the compiled re_pattern, which is a reference on OTP 28; Elixir < 1.19 cannot escape references when injecting an attribute into a function body, so the package did not compile for consumers on 1.17 to 1.19 × OTP 28 (a combination the old window admitted). The patterns are now built by a defp (identical regexes, flags, and order); with the floor now at 1.20 that combination is out-of-window, and the defp keeps the escape class dead if the floor ever drops below 1.19.
  • mix dialyzer on a fresh PLT no longer reports 13 unknown-function/ unknown-type warnings in test/support: use AshSqlite.Repo emits Ecto.Adapters.SQL delegations, and the deps-PLT app enumeration does not reliably include :ecto_sql; it is now explicit in plt_add_apps with the reason inline.

Added

  • scripts/check-currency.sh: exits nonzero whenever mix hex.outdated shows resolvable drift, and prints the packages whose latest release the resolver will not take under current requirements; each of those must carry an inline deliberate-pin reason in mix.exs. Fail-closed: an errored hex.outdated run (lock mismatch, resolver failure) also exits nonzero.

1.0.4 - 2026-09-16

Current-Ash compatibility release: the repo's own app surfaces carry Ash 3.33.0's required default_string_length_count, and the byte-bound correction family that requirement exposed is fixed.

Fixed

  • Fixed byte-length validation for event identifiers, response snippets, and error summaries:
    • Event.new/1 and the dispatcher's event guards bound ids/types by BYTES, not String.length (graphemes); under Ash >= 3.33.0 :codepoints, a 128-grapheme combining-character type (512 bytes) passed validation and then failed every endpoint's :dispatch create. The inbound side already bounded bytes; outbound now matches, in either counting mode.
    • A thrown 255-character token no longer overflows last_error: "throw: " <> classify_token(...) could reach 262 bytes and fail the enqueue-failure ledger write itself (mode-independent, ASCII); the combined string is capped now, like the :exit sibling.
    • An inbound handler failing with an invalid-UTF-8 binary no longer loses its failure record: the error class collapses to the redaction floor's [binary] placeholder instead of failing the :mark_failed write and leaving the delivery re-drivable.
  • Captured snippets and error summaries are now capped in BYTES instead of grapheme-sliced. Under Ash >= 3.33.0 :codepoints counting the injected max_length constraints count codepoints, and a grapheme-sliced 2048-character snippet of combining characters spans 4000+ codepoints; the post-send ledger write then violated its own constraint and crashed (mark_succeeded failed on a hostile response body), the same re-send poison class the control-byte strip closes. The byte cap (on a codepoint boundary) bounds the value under every counting mode, on every supported Ash. Covers the response-snippet capture path, the redaction floor, and the inbound error_class / dispatcher exit-string bounds. Regression tests cover combining-character inputs that exceeded stored value limits.
  • Current-Ash compatibility: Ash >= 3.33.0 requires every application that compiles resources to set config :ash, :default_string_length_count (the app-level half of GHSA-cwjv-574p-59f6), which broke the CI floor and Livebook legs; both resolve Ash lock-free at latest and failed resource compilation. The test application (config/test.exs, repo-local and never shipped), the get-started Livebook, and the tutorial now carry the setting. The package itself still writes no :ash configuration; consumers keep that choice, and both documented values work (see UPGRADING.md). A new tripwire test locks the boundary: lib/ never writes :ash application environment.
  • The tutorial's requirements line now matches the tested floor (Elixir ~> 1.17; the ~> 1.15 claim was disproven by the CI floor leg, per the public support policy).

Changed

  • mix.lock: ash 3.33.4, and the dev/test substrate cleared of its published advisories (ash_sqlite 0.2.19 / ash_sql 0.7.5, both test-only and never shipped in the package; mix hex.audit is now clean).

1.0.3 - 2026-08-23

Docs-and-tests release (no functional changes; 1.0.2's gate and fixes unchanged):

Changed

  • The send-failure contract tests dropped their 512MB bodies for 16MB with the peer's receive window pinned to 1KB, preserving the same in-flight send-failure check with lower memory use. CI uploads the cover HTML when the coverage gate reds (triage data, not guesswork).

Docs

  • UPGRADING carries the 1.0.2 behavior notes (the :httpc literal-IP HTTPS refusal, the :http_opts threading).
  • The :httpc and Bounded moduledocs document the literal-IP posture and :cacerts trust-store configuration.

1.0.2 - 2026-08-22

CI now requires 100% line coverage in the coverage surface declared in mix.exs.

Added

  • Target.ssl_options/2 and both HTTP adapters accept an injectable :cacerts trust bundle ([cacerts: der_list] in the adapter opts, or use AshHooks.Worker, http_opts: ... on the Oban path): pin a private CA for private-CA endpoints. Default UNCHANGED (the OTP CA store). The worker's http_opts takes compile-time literals, or an {m, f, a} resolved per-perform for computed bundles.
  • TLS success paths are covered by REAL CA-verified loopback sessions against committed local fixtures, including the literal-IP iPAddress-SAN floor and its fail-closed mismatch.

Fixed

  • AshHooks.Http.CertSan.ip_san_match?/2 fails closed (returns false) instead of CRASHING its caller when a certificate's SAN extension carries non-DER bytes: asn1's decode EXITS on invalid tags, which the previous error-only rescue could not catch.
  • AshHooks.Http.Httpc (the alternate adapter) refuses literal-IP HTTPS destinations with {:error, :ip_literal_https_needs_bounded}: it never holds the socket, so the iPAddress-SAN floor cannot run there and chain-validation alone would let any chain-valid certificate authenticate the endpoint IP. Use AshHooks.Http.Bounded (the default) for literal-IP HTTPS endpoints.
  • use AshHooks.Worker threads :http_opts into the delivery config (the option was previously accepted and silently dropped).

Changed

  • mix test --cover GATES at 100% line coverage of lib/'s runtime-reachable lines (CI fails on a miss). The ignore list carries exactly the :cover-invisible classes: Spark's generated DSL sections, test-support modules, and four compile-window module-body lines. 31 provably-dead defensive arms were DELETED with proofs (commit d6f3788) rather than exempted; the shipped surface behaves identically.

1.0.1 - 2026-08-22

Documentation and tests release with no functional changes. Added concurrent-ingest and HTTP-buffering regression tests:

Added

  • The fenced ledger's exactly-once claim is now pinned by a TRUE concurrent race test (8 simultaneous same-key ingests on a 3-connection sqlite pool: exactly one :created, one row), and the same race without the storage unique index proves the failure mode: sqlite fails CLOSED with a loud storage error, zero rows. The InboundDelivery moduledoc cites both.
  • The :httpc adapter's giant-non-2xx window is now MEASURED (dribble probe: ~4.65MB transient for a 4MB error body against a 16-byte bound) with a committed containment test pinning the final cut; the public support policy carries the numbers.

Fixed

  • The missing-index hazard is documented accurately: on storage layers with native conflict support (sqlite, postgres) a missing unique index errors the ingest loudly; the previously documented "two rows, both :created" shape applies to degraded-upsert layers. The as-built floor is stronger than the docs claimed.

1.0.0 - 2026-08-22

1.0.0 is the semantic-versioning baseline: no public API removals or renames from 0.2.0 through 0.2.2. Three behavior corrections follow; see migration notes in UPGRADING.md.

Fixed

  • Truncated chunked responses no longer classify as success. The default HTTP adapter returned a partial body as {:ok, ...} when a chunked response was cut by early close; a 2xx on partial bytes could mark a delivery :succeeded. Chunked now returns {:error, :truncated_body} exactly like the Content-Length framing, and the driver retries.
  • The literal-IP https certificate check actually works now. The iPAddress-SAN matcher was unreachable since birth (found by the new dialyzer gate): every literal-IP https endpoint was rejected fail-closed with :cert_ip_mismatch. Extracted to the tested AshHooks.Http.CertSan. Both address families now verify against certificates.
  • A hostile chunked response can no longer balloon worker memory. The chunk consumer accumulated the ENTIRE attacker-declared chunk before trimming to the body bound; an 8MB declaration held ~16.8MB in the worker against a 16-byte bound. Consumption is now phase-bounded: keep at most the allowance, discard the excess slice-wise (one receive slice held at a time), and a chunk terminator that is not CRLF is now {:error, :malformed_chunked} instead of being silently consumed (a malformed 2xx can no longer classify as succeeded). Run-on chunk-size lines without a terminator are refused past a sane bound instead of being buffered.
  • AshHooks.Delivery.prune/2 now returns {:error, error} when the resource lacks inserted_at, matching AshHooks.Ingress.prune/2 and its own documented return type. It previously raised ArgumentError.

Added

  • Semver and support policy: the covered public surface is named, deprecations run two minors, and the minimum supported versions are CI-tested (Elixir ~> 1.17 / Erlang/OTP 27 / Ash ~> 3.0 / Oban ~> 2.20 optional). The previously claimed Elixir 1.15 floor was never buildable with current Ash and is corrected here; 1.0.0 is the first release whose floor is actually tested.
  • SECURITY.md with a private disclosure channel (GitHub private vulnerability reporting, enabled), scope, and known posture notes; CONTRIBUTING.md and UPGRADING.md. All three ship in the tarball and render on hexdocs.
  • Dialyzer gate on the public API (local + CI): the first run caught the dead IP-SAN matcher above.
  • CI: a floor leg resolving dependencies at the declared minimums (it disproved the old 1.15 claim on its first run), a package leg checking the hex tarball ships every documentation file and that the DSL cheat sheets match the DSL, and an advisory coverage report.
  • @spec on the HTTP behavior's request/5 (both adapters), AshHooks.dispatch/4, the resource extensions' statuses/0/signing_modes/0 (now documented), and the internal HTTP target-resolution helpers.
  • A dedicated extension-shape test suite for AshHooks.OutboundDelivery, pinning the injected attributes, the unique_delivery identity, and the :dispatch no-touch-upsert contract.

Changed

  • Read posture documented honestly: read access to the ledger/delivery resources is consumer-governed; the package injects no read policies. README → Security carries the deny-by-default policy recipe; the resource moduledocs now carry READ-EXPOSURE warnings. (No code change: reads were always consumer-governed; the docs previously implied otherwise.)
  • Install guidance is {:ash_hooks, "~> 1.0"}; the README (previously pinned ~> 0.1.0, one feature-release behind) and tutorial both corrected, with the install-constraint check added to the release checklist.

0.2.2 - 2026-08-22

Fixed

  • usage-rules.md now ships in the hex tarball (the Ash AI-assistant convention reads it from the package) and renders on hexdocs. It was previously GitHub-only.

0.2.1 - 2026-08-22

Added

  • A runnable get-started Livebook (guided tour: inbound verify/dedup, a live local delivery, telemetry, retention), verified headless in CI on every push. No functional changes.

0.2.0 - 2026-08-22

Added

0.1.1 - 2026-08-22

Changed

  • README rewritten as a package front door (no functional changes): audience/register pass; internal build references removed.

0.1.0 - 2026-08-22

Added

  • Inbound machine: AshHooks + AshHooks.InboundDelivery extensions, AshHooks.Ingress (verify-before-trust, fenced unique-ingest dedup ledger, lease-based claim, crash-window re-drive), provider behavior with ComplyCube/HubSpot v3 references and a test provider.
  • Outbound machine: AshHooks.dispatch/4 fanout with per-endpoint isolation and enqueue-repair CAS; AshHooks.OutboundDelivery, AshHooks.Subscription, AshHooks.Endpoint extensions.
  • Delivery runtime (AshHooks.Delivery) + host-injected use AshHooks.Worker: Standard Webhooks signing (standard/dual/legacy envelopes), row-owned retry policy (Retry-After, jittered backoff, dead-letter ceiling), 410 durable disable, redirect refusal, send-time SSRF re-check.
  • AshHooks.Http adapter behavior with a memory-bounded native HTTP/1.1 default (AshHooks.Http.Bounded, with every read capped under all framings) and an OTP :httpc alternative.
  • Response-snippet redaction floor: no body bytes by default (fixed-grammar status + allowlisted content-type summary); per-call snippet_capture opt-in under the in-package redaction floor (NFKC homoglyph folding, bounded-fixpoint decode chain, separator-tolerant markers, ≥16-char union-alphabet entropy rule); fail-closed consumer snippet_redactor callback; [captured] marking.
  • Telemetry (the public support policy floor: ids/integers/fixed atoms/classified reasons only, never secrets or bodies): ingress verify/dedup/claim, dispatch enqueue_failed, delivery attempt/result/backoff/dead_letter/ disable; AshHooks.Telemetry.fingerprint/1.
  • Igniter installer, DSL cheat sheets, get-started tutorial, usage-rules.md.

Security

  • Package floors shipped in-code: secrets as sources only (literals rejected at parse), default-deny machine-written ledger fields, SSRF guard at registration and send, NO headers stored on either ledger at all, no response-body persistence by default, classified-only error strings.