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 :onis enabled. The Plug resolver and direct ingress accept transient upstreamhost_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/2before calling the signer. - Optional
record_signing_provenance :onrecords 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-versionsfiles. 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_resultfailures 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 retryablehandler_crashedfailures.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
unreadand 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/3andtenant_type_supported?/2expose 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.PublicKeyandnew/2validate pinned asymmetric material against its declared algorithm, digest, padding, and curve.AshHooks.Tenancy.from_row/1recovers a stored row's tenant throughtenant_from_attributebefore reuse in tenant options or custody.AshHooks.InboundSourceoptionsledger,source_attribute,scope,providers,custodian,custody_tenant_key,key_registry,max_overlap_seconds, anddefault_overlap_secondsconfigure 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, andunpause/2expose source issuance, lost-disclosure recovery, retirement, public-key registration, and pause control.AshHooks.InboundSource.adopt_provider_alias/4returns:invalid_limit,:source_mismatch, or:provider_mismatchfor invalid adoption arguments.AshHooks.Ingress.resolve_source/3andAshHooks.Inbound.ResolvedSourceexpose resolved provider, cast scope, pause state, and verification keys. Pass the result through the:resolved_sourceingest context to reuse it.Endpoint option
secret_resolverresolves unmarked byte slots during migration.Registry option
issue_timeoutdefaults to 900 seconds.AshHooks.KeyRegistry.sweep/2reconciles owners and destroys retired keys. The extension injects:read,:issue_key,:transition_key, and:prune_keyswhen absent. Destruction failures emit[:ash_hooks, :key_registry, :destroy_failed]with measurement%{count: 1}and metadataregistry,ref, andreason.AshHooks.Provider.Scheme.decode_payload/3accepts a JSON decoder, andAshHooks.Provider.Signature.jws/3accepts thejson_decoder:option for protected headers and claims.Monitored delivery and finalization children inherit the caller's configured tracer context.
AshHooks.InboundSourceowns 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/4stamps and claims older receipts in bounded tenant phases, with handlers running after each claim commits.Optional provider callback arities accept
AshHooks.Provider.DeliveryContextwith tenant, source, scope, provider alias, and persisted delivery identity. The callbacks areparse_event_type/2,event_identity/2, andhandle_event/3.Endpoint custody key issuance through
create_with_key/3,roll_secret/2withmaterial:orgenerate:, andreissue_secret/2for 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/2adopts occupied standard current and previous byte slots throughsecret_resolverwhile preserving lifecycle timestamps. Legacy slots also adopt withlegacy_key_lifecycle :on; otherwise they remain host byte references and keep signing throughsecret_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/3for 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_keydefines the host's equality contract for custom tenant types. Custody endpoints refuse unsupported types without it.Opt-in
key_material: :custody_onlyrefuses 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_decoderapplies an application JSON policy to JWS protected headers, claims, and delivered payloads for each request.Optional provider callback
decode_payload/2receives the request's JSON decoder. Ledgers configuringjson_decoderrequire it for host-defineddecode_payload/1; generated decoders honor the policy directly.AshHooks.Provider.Conformancechecks that a hand-writtendecode_payload/2uses 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 inspectpending/2, repair andrearm/3, andprune/2old destroyed rows. Generation fences reject stale destruction results.Endpoint options
custodianandkey_registryinject 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 :oninjects a nonnullable booleanpausedcolumn, defaulting tofalse. Paused subscriptions create no new delivery rows; existing deliveries continue. The default:offkeeps existing schemas unchanged. Applications pause and resume through ordinary updates.Endpoint option
legacy_key_lifecycle :onopts legacy signing keys into overlap validation, retirement scheduling, signing deadlines, and fenced first-use timestamps. It requireskey_lifecycle :onand 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/2validates 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_secondsanddefault_overlap_secondsconfigure 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/3sets a retirement time for the selected standard or legacy previous key, including an undated reference adopted withkey_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.Keycarries 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/1for spec-shaped keys andAshHooks.Custody.display_fingerprint/1for 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, andKeyUnavailableerrors 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 returnsMalformedPayload; 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_attributebefore 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_decoderrequirement to every provider in a source declaration's allowlist, so a host-defineddecode_payload/1without/2cannot 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 fromAshHooks.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/4accepts 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. AnAshHooks.Custody.Keyin an RSA, ECDSA or Ed25519 key list reportsKeyKindMismatchunless another key verifies, instead ofInvalidSignature.Package database phases pass
Ash.transact/3the tenant key, converted withAsh.ToTenantfor 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,pausedandprevious_secret. A consumer importing:ash_hooksinimport_depsno longer hasmix formatadd 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/2andtest_send/2refuse 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_failedand 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_owneraction instead of the host primary read's filters, preparations or pagination. The resource'sbase_filterstill 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
UnknownErrorvalues 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
transportsetting that is not a resolver, refuse the attempt as a retryabletransport_resolutionfailure instead of falling back to HTTP. Error contents are neither stored nor emitted. Returningnilstill 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 becomesctx.signaturefor a provider on the default:headersignature source; a missing or repeated header is refused as unsigned.- Optional
AshHooks.Provider.handshake/1andAshHooks.Provider.response/1callbacks for sender challenges and acknowledgment protocols. The plug also accepts a host response policy. AshHooks.BodyReader.put_raw_body/2andraw_body/1provide 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
securityjob 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:hexand:gitentry Mix counts (scripts/check-advisories.sh, with a fixture lock holding both kinds).mix hex.auditfails on a retired package.
Fixed
- With
ingress_tracking :on, the generated:record_rejectionaction accepted:ideven on ledgers without a writable:idattribute (for example one declared withuuid_v7_primary_key), which Ash's accept validation reports at compile time. It now accepts:idonly when:ingestdoes. - 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, andAshHooks.OutboundEvent.list/2raised 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.Workeraccepted 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:transportother thannilor{module, function}, and a function literal for:delivery_headersor: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:towithout:from. - Health sweeps enforce the full warning interval from the stored warning time, including early and overlapping sweeps. The interval is the new
auto_disableoptionwarning_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_verificationrows. - 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
:idattribute; 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(andComplyCube.Event),AshHooks.Provider.HubSpotV3(andHubSpotV3.Eventanddecode_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, andAshHooks.Provider.Wix. Replacement: a provider module in your application, usuallyuse 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
providerno longer resolvesAshHooks.Provider.<CamelizedName>; it fails to compile with a message naming the fix. Replacement: setprovideron 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 rawr || ssignatures; 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.Schemedocuments those options.new!/1validates them,verify/4verifies with them directly, andpayload_identity/1,decode_payload/2,timestamp_header/1andsignature_source/1back the generated callbacks.- A provider configured with
signature: :jws_bodyalso getsdecode_payload/1, which stores the verified JWS payload, andevent_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/3and:jws_bodyaccept only unpadded base64url segments, as RFC 7515 requires. A token that contains=fails with:invalid_signature.AshHooks.Provider.Signatureis public:hmac/4,rsa/4,ecdsa/4,ed25519/4,jws/3,compare/2,header/2andcheck_timestamp/3, for providers that implementverify_signature/3themselves.- The optional
signature_source/0callback accepts:request, for providers that read their own signature from the request headers; ingress then needs noctx.signature. AshHooks.Ingress.ingest/4accepts the request headers as an ordered list of{name, value}pairs, such asconn.req_headers, as well as a map. Providers receive every line in arrival order in the newctx.header_list, and repeated lines are joined with", "inctx.headers. A map the host passes is delivered unchanged, as before.AshHooks.Provider.Hmacaccepts:sha384and:sha512algorithms.- A "Verify any sender" guide with recipes for common signature shapes.
Changed
AshHooks.Ingress.ingest/4fails verification whenheadersis neither a map nor a list of binary{name, value}pairs. A list reaches providers as a map inctx.headersand in full inctx.header_list.
2.3.0 - 2026-11-11
Added
- Inbound routes can accept
application/x-www-form-urlencodedbodies: declarebody_format :formon the route, or return it from a provider's optionalbody_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.EasyPostmodule. 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
pausedandprevious_secretsources 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/3that 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: declaringauto_disableinjects thedisable_warned_atmarker 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.OutboundAttemptextension 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 arenilwhen 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 withattempts: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 :onon the endpoint resource injects per-row capture columns; an endpoint that setsresponse_capture: truerecords bounded (response_capture_max_bytes), redacted response bodies and onlyresponse_header_allowlist-named response headers in its attempt rows. Capture stays off by default everywhere.Delivery-log queries.
AshHooks.Delivery.list/2andAshHooks.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/2sends 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 freshmsg_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 :onon the delivery ledger injects thetestcolumn,AshHooks.Delivery.test_send/2rows carrytest: true, attempt history rows flag themselves, and both list queries filter ontest:; 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 anexamplepayload. Health stats report FIRST-ATTEMPT successes separately from EVENTUAL successes (and the delivery count). Attempt history prunes WITH its delivery rows (prune/2's:attemptsoption). 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/2queries inbound deliveries by source, status, event type, and time range with keyset pagination;counts/2answers the window's story (received, duplicates ignored, failed verifications, handler failures) withingress_tracking :onon the ledger (theduplicatescounter column and payload-less:failed_verificationrejection rows, digest identity). The inbound DSL'sprevious_secretsource rotates a source with an overlap window (both keys verify until the option is removed), andpaused(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-partitionedunique_attemptindex (the delivery ledger's pattern);AshHooks.Endpoint.expire_previous_secret/2gained its:tenantoption.The event log. The new
AshHooks.OutboundEventextension records each dispatched event ONCE (id, type, declared payload version, time, and exact payload bytes), whether or not any endpoint was enabled (wire it withevents: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/3sends 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.Transportis 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-shapedrequest/5receiving the SAME signed request the wire would, with the runtime's attempts, attempt history, classification, backoff, and telemetry applying unchanged. Route per endpoint withtransport: {module, function}(worker option or direct-run config; the direct-run config also accepts a 2-arity function) returning the transport module ornilto 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 theevent_filterscolumn (: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'smetadata.The event catalog and payload-version pinning. The
outboundDSL declares each event type's metadata:description,payload_schema(any term your docs renderer understands),version(default 1), and optionalpayload_versions(a map ofversion => {module, function}variant builders). Read it back throughAshHooks.Catalog.entries/1andentry/2for event pickers and doc generation. Declaringversion_pinning :onon the endpoint resource injectspinned_payload_version. Endpoints without a pin, or pinned to the declaration's currentversion, receive the dispatch payload; other pins receive the matchingpayload_versionsbuilder'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/2computes one endpoint's trailing-window health from its attempt history: success rate and nearest-rank latency percentiles (p50/p90/p99 ms). The newauto_disablesection 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/3disables 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 :onon 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 unlocksAshHooks.Endpoint.roll_secret/2: the incumbent reference moves toprevious_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 byexpire_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/2is the scheduled sweep;expire_previous_secret/1retires 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/2re-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 atresend_baseline.AshHooks.Delivery.replay/2re-arms a filtered set (endpoint, event type, status list, time range) withdry_run: truecounting matches and:per_second/:limitbounding 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 newresend_tracking :onDSL (four migrated columns); existing schemas are untouched. Every re-arm emits[:ash_hooks, :delivery, :resend].A public send-time destination policy seam.
AshHooks.DestinationPolicyis 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 directAshHooks.Delivery.run/2config) 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(terminaldestination_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 retryabledestination_policy_failed; a policy defect never dead-letters deliveries. A configured policy takes precedence over the boolean:ssrf_checkseam; with no policy configured, behavior is unchanged.Runtime-configurable worker timing.
use AshHooks.Workeracceptsruntime_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 literalhttp_optstimeout: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 iscallback_failed). The public resolverAshHooks.Worker.resolve_config/2backs 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/1instead of the booleansafe_url?/1, which folded unresolvable into unsafe: a resolver outage (or mere congestion past the two-second resolution ceiling) permanently dead-lettered healthy endpoints atattempts == 1under theunsafe_destinationlabel, while the same condition surfacing one layer later (inside the HTTP adapter) retried as transport. Now a validated-unsafe answer still dead-letters immediately asunsafe_destination; an unresolvable host retries under its honest label:nxdomainwhen every queried address family answered authoritatively negative,resolve_timeoutfor an outage, congestion, or mixed evidence (both in the telemetry reason vocabulary;nxdomainhad 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 isunresolved_host(also newly in the vocabulary, as it previously collapsed tounclassified). Consumer-observable: rows that would have been terminal at attempts == 1 now climb the backoff ladder; consumers branching on an immediateunsafe_destinationfor DNS-dark endpoints seefailed_retryable/nxdomain/resolve_timeoutrows instead. The injected:ssrf_checkboolean seam is unchanged (false still dead-letters asunsafe_destination). - Compiled worker-budget tripwires.
use AshHooks.Workernow refuses, at compile time, related budgets whose silent misfit stalls rows or walls off every slow send: Oban's:max_attemptsmust 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_optstimeout: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_secondsmust be at least:base_backoff_seconds. A literal:http_optsvalidate_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 raiseArgumentErrorat compile.
Docs
- The
:http_optsoption ofAshHooks.Workernow 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. TheAshHooks.Deliveryclassification 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, novalidate_destinationbypass). 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.3and 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.auditandscripts/check-currency.share 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_503stays 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_enqueuemachine primitive gains an optionalenqueue_lease_expires_atargument (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:duplicatewhere 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_failedinstead 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
<= 8accepted an unreachable value.
2.0.2 - 2026-10-07
Fixed
- Outbound
Retry-Afteris 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 byretry_after_cap_seconds(default 86,400s), notmax_backoff_seconds(default 3,600s); if you shortenedmax_backoff_secondsto finish retries sooner, also lowerretry_after_cap_seconds. - Test dependency updates:
ash_postgres2.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_keyfor 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_pendingbefore 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.HubSpotV3module changed its default deduplication identity to canonicalize the batch while excluding each outer event'sattemptNumber. The optional providerevent_identity/1callback 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_keyand:sslthrough the package's application dependencies; optional packages are unnecessary for default HTTPS. - Direct delivery calls apply the documented retry defaults for omitted or
nilsettings, including the attempt ceiling and boundedRetry-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.Eventmapping 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_attributeon theoutbound_deliverysection. The exact payload-bytes column's name is configurable (default:payload): rename it when the consumer's domain reservespayloadfor its own sole payload store. The injected column, the:dispatchaccept list, and every signing/sending read follow the configured name; a name colliding with another injected field fails closed at compile.prune_action :noneon theoutbound_deliverysection. Opt out of the retentiondestroy :pruneaction's injection for append-only audit ledgers (no destroy action exists on the resource at all);AshHooks.Delivery.prune/2then fails loud with a named error; deletion is the consumer's own surface. Default:destroyis unchanged.status_attribute/enabled_values/disabled_valueon the newendpointsection. Map the durable enable/disable onto the consumer's OWN switch (e.g. anactiveboolean):statusis 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 throughAshHooks.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 (
postgresjob; the suite is env-gated byASH_HOOKS_POSTGRES=1and excluded from ordinary dev runs).ash_postgresis a dev/test-only dependency; it never ships or constrains consumers.
Fixed
:dispatch/:ingestno longer accept:idon resources whose primary key is a non-writable:id(e.g.uuid_v7_primary_key): Ash'sValidateAcceptraised at compile on exactly that consumer shape, making the extensions unadoptable without replacing the PK. The accept lists carry:idonly 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-:idprimary 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 theCorrection 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 custommark_sendingCAS and inbound claim fence.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:disableddead-lettered, so a consumer-redeclaredstatuswith extra values delivered). The dispatcher's skip and the send path now route through the ONEAshHooks.Endpoint.enabled?/1check, which fails closed by design. AshHooks.Subscription.matches?/2normalizesevent_typesentries withto_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 redeclaringevent_typeskeep 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 --checkran without an extension list and checked nothing; it now passes the five extensions explicitly, so a staledocumentation/dsls/actually fails the build (the sheets in this release are regenerated under that invocation). - Dev/test
mintbumped 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_postgres2.13.1 is added dev/test-only for the Postgres leg above.
Docs
- Policy obligation at the extension site (
OutboundDelivery,Endpointmoduledocs): 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:disableaction. - Deterministic
Event.idguidance (Event,Dispatchermoduledocs): 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.Httpmoduledoc): headers must be a LIST of{name, value}tuples (a map silently losesRetry-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_secondssemantics (Workermoduledoc): 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 (
Deliverymoduledoc): 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(:tenantopt),AshHooks.Ingress.ingest/4(ctx[:tenant]), the claim/mark/ renew/redact/prune/reap heads (:tenantopt, new optional arity),AshHooks.Delivery.run/2(tenant recovered from job args), and both prunes. The tenancy contract: consumers declaremultitenancy :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?: trueis rejected; it silently disables fail-closed reads). A compile-time verifier additionally rejectsmultitenancy :bypass,:bypass_all, and:allow_globalactions on multitenant package resources. - Per-tenant operations:
AshHooks.reap_all/2andAshHooks.prune_all/2sweep 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:pendingby 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-arityf(ref, tenant)resolver contract); the inboundsecret fn tenant -> ... endsource; the provider behavior's optionalwebhook_signing_secret/2(per-tenant secret custody;use AshHooks.Providerships an overridable default delegating to/1); and:tenantin theverify_signature/3context map. - Oban args carry the tenant: the generated
enqueue/2serializes the row's tenant. Strings and integers survive JSON unchanged; atoms arrive as strings. Pair a customparse_attributewithtenant_from_attributeso 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:reconciledstatus. - 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
:inetshttpd fixtures hardcodedserver_root: "/tmp", nonexistent on Windows; one failure hid as asetup_allinvalidation that silently excludes a whole module's tests from the failed count; both now useSystem.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).
- two
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.0pin 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-versionsand 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.exsrefuses any OTP release CI does not test (currently 28/29) before anything compiles, becauseSystem.version/0does 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.auditnow 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.auditclean before and after (and OSV shows no advisories against the three new versions).
Fixed
- A
%Regex{}inside a module attribute (@redaction_patterns) embeds the compiledre_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 adefp(identical regexes, flags, and order); with the floor now at 1.20 that combination is out-of-window, and thedefpkeeps the escape class dead if the floor ever drops below 1.19. mix dialyzeron a fresh PLT no longer reports 13 unknown-function/ unknown-type warnings intest/support:use AshSqlite.RepoemitsEcto.Adapters.SQLdelegations, and the deps-PLT app enumeration does not reliably include:ecto_sql; it is now explicit inplt_add_appswith the reason inline.
Added
scripts/check-currency.sh: exits nonzero whenevermix hex.outdatedshows 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 inmix.exs. Fail-closed: an erroredhex.outdatedrun (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/1and the dispatcher's event guards bound ids/types by BYTES, notString.length(graphemes); under Ash >= 3.33.0:codepoints, a 128-grapheme combining-character type (512 bytes) passed validation and then failed every endpoint's:dispatchcreate. 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:exitsibling. - 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_failedwrite 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
:codepointscounting the injectedmax_lengthconstraints 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_succeededfailed 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 inbounderror_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:ashconfiguration; consumers keep that choice, and both documented values work (see UPGRADING.md). A new tripwire test locks the boundary:lib/never writes:ashapplication environment. - The tutorial's requirements line now matches the tested floor (Elixir
~> 1.17; the~> 1.15claim 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.auditis 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
:httpcliteral-IP HTTPS refusal, the:http_optsthreading). - The
:httpcandBoundedmoduledocs document the literal-IP posture and:cacertstrust-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/2and both HTTP adapters accept an injectable:cacertstrust bundle ([cacerts: der_list]in the adapter opts, oruse AshHooks.Worker, http_opts: ...on the Oban path): pin a private CA for private-CA endpoints. Default UNCHANGED (the OTP CA store). The worker'shttp_optstakes 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?/2fails closed (returnsfalse) 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. UseAshHooks.Http.Bounded(the default) for literal-IP HTTPS endpoints.use AshHooks.Workerthreads:http_optsinto the delivery config (the option was previously accepted and silently dropped).
Changed
mix test --coverGATES at 100% line coverage oflib/'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. TheInboundDeliverymoduledoc cites both. - The
:httpcadapter'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 testedAshHooks.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/2now returns{:error, error}when the resource lacksinserted_at, matchingAshHooks.Ingress.prune/2and its own documented return type. It previously raisedArgumentError.
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.
@specon the HTTP behavior'srequest/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, theunique_deliveryidentity, and the:dispatchno-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
- Retention hooks:
AshHooks.Ingress.prune/2andAshHooks.Delivery.prune/2(terminal rows older than a cutoff, keyed on the resource'stimestamps(); non-terminal rows never deleted), andAshHooks.Ingress.redact_payload/4(payload field-redaction under the claim fence; the original-bytes digest is preserved). Deleting a terminal row re-opens its dedup identity; set TTLs beyond replay/re-emission horizons.
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.InboundDeliveryextensions,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/4fanout with per-endpoint isolation and enqueue-repair CAS;AshHooks.OutboundDelivery,AshHooks.Subscription,AshHooks.Endpointextensions. - Delivery runtime (
AshHooks.Delivery) + host-injecteduse 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.Httpadapter behavior with a memory-bounded native HTTP/1.1 default (AshHooks.Http.Bounded, with every read capped under all framings) and an OTP:httpcalternative.- Response-snippet redaction floor: no body bytes
by default (fixed-grammar status + allowlisted content-type summary);
per-call
snippet_captureopt-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 consumersnippet_redactorcallback;[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.