Sending signals
Post conversations and context events from anything: an in-house helper, a custom AI, a script over an export. The one contract everything else here is built on.
POST /api/signals is how a source that is not a connected helpdesk gets conversations into a workspace: a team's own in-house tool, an inbound support address, a script over an export. What arrives becomes the same rows a helpdesk sync produces, and from there the loop is identical — findings, problems, experiments, measurement.
What a key is, and is not
A key says which workspace a request belongs to, and which source it speaks for. It authorises sending signals and nothing else: it cannot start a playbook, read a conversation back, change a setting, or reach your helpdesk. Receiving events from a system is never permission to act on it.
Create one under Connections. The key is shown once, when it is made, and is stored here only as a hash — there is no way to read it back, and no support request that can recover it. Lost one, make another and revoke the old one.
sa_4f2b9c1ea87d0356_kZ3n... ← sa_<key id>_<secret>
The key id is the public half. It appears in the audit trail and in the Connections list so a key can be identified without ever handling the secret.
A widget key (saw_…) is a different thing. It is safe to put in a page because it can only submit a question, feedback or problem report through POST /api/widget. Presenting one here is refused. See [docs/widget.md](widget.md).
The request
curl -X POST https://app.example.com/api/signals \
-H "Authorization: Bearer sa_4f2b9c1ea87d0356_kZ3n..." \
-H "Content-Type: application/json" \
-d '{
"conversations": [
{
"id": "ticket-8841",
"startedAt": "2026-09-09T09:12:00Z",
"updatedAt": "2026-09-09T09:41:00Z",
"state": "closed",
"person": { "id": "u_2213", "email": "dana@acme.test", "company": "Acme" },
"transcript": [
{ "role": "customer", "text": "I cannot add a second seat to our plan." },
{ "role": "ai", "text": "You can add seats under Billing → Seats." },
{ "role": "customer", "text": "There is no Seats section on my Billing page." }
],
"ai": { "participated": true, "claimedResolved": true },
"rating": { "conversation": 2, "comment": "Did not answer the question." },
"facets": { "plan": "team", "locale": "en" }
}
],
"events": [
{
"id": "inc-2026-09-10",
"kind": "incident",
"startsAt": "2026-09-10T08:00:00Z",
"endsAt": "2026-09-10T11:30:00Z",
"note": "API outage in us-east-1"
}
]
}'
At most 500 conversations and 500 events per request, and 4 MB of body. A source with more sends more requests. Conversations and events can arrive together or in separate posts. Sending an event is never permission to act.
Fields
| Field | Required | What it is |
|---|---|---|
id | yes | Your own id for the conversation. Unique within your source. |
startedAt | yes | ISO 8601. When the person first made contact. |
updatedAt | no | ISO 8601. When it last changed. Defaults to startedAt. |
state | no | open, closed or snoozed. Defaults to closed. |
person | no | id, email, company. Used to recognise the same person; see below. |
transcript | yes | Turns in order, each role of customer, ai or agent, plus text. At most 1,000 turns. |
transcript[].tools | no | On an ai turn from your own agent: the tools it called, each { "name": "billing.refund_status", "ok": false }. At most 50. Only the name and whether it succeeded are kept — send a result and it is ignored. |
transcript[].retrieved | no | On an ai turn: the passages it retrieved, each with an articleId, a url or the passage itself (at most 4,000 characters). At most 20. Redacted like a transcript; an address loses its query string. |
ai.participated | no | true or false: whether an AI answered. Inferred from the transcript when absent. |
ai.claimedResolved | no | true or false: whether your system claims the AI resolved it. Recorded as your claim, never as our finding. |
ai.citedArticleIds | no | Articles the AI cited, by your id for them. At most 50 strings. |
rating | no | conversation and ai as whole numbers from 1 to 5, and the customer's comment as text. |
facets | no | Brand, team, locale, plan. What comparisons and steering match on. Values are redacted like a transcript, and an address loses its query string. |
traceIds | no | The OpenTelemetry trace ids of this conversation's answers, 32 hex characters each, at most 50. Kept so feedback naming an answer by its trace finds the conversation (below). Sent over OpenTelemetry, they are kept for you. |
A resend of a conversation that leaves out rating keeps the rating already held, which is how feedback sent between two sends of the same conversation survives the second one.
tools and retrieved are how a failure of your docs is told apart from one of your agent's instructions or a tool it called: an answer that retrieved the right passage and still said something else is a different fix from one that retrieved nothing. Send them when your agent knows them; everything else works without. Two things make them more useful. Send the passage your agent actually read, not only its article: the passage decides whether the right words were found, and an article's id alone cannot tell the paragraph that answered from its neighbour. And send "ok": false for a tool that returned nothing your agent could use (no matching order, an empty list), not only for one that errored: an empty result the agent then answered past is a tool failure we can only see if you say so.
An entry whose fields do not have these shapes is rejected with its reason and the rest of the batch is stored. A workspace whose plan takes nothing in through keys (the free audit workspace) answers every key with 403 plan_limit.
Events
Optional. An incident, release, holiday, closure, pricing change or campaign, recorded on the same time axis as problems and measurements. A retry with the same id from the same source is one row.
| Field | Required | What it is |
|---|---|---|
id | yes | Your own id for the event. Unique within your source. |
kind | yes | incident, release, holiday, closure, pricing_change or campaign. |
startsAt | yes | ISO 8601. |
endsAt | no | ISO 8601. Omit for an open holiday or closure, or a release at startsAt. |
note | no | Workspace-typed. Redacted on the way in. |
What happens to the text
Personal information is removed before the first write, exactly as it is for a live helpdesk sync — an uploaded or posted transcript gets no weaker treatment for having been pushed rather than pulled. person.email and person.id are used to recognise the same human across conversations, as a salted hash, and are then discarded: no contact identifier is stored in a workspace database. Sent together, an id and an email are asserted to be one person's, so a person known by that email from another source and a person known by that id become one; sent in separate conversations, they are never joined. The customer's rating comment is redacted on the same path as message text. So are the passages your agent retrieved, and the text is redacted by the workspace's own patterns (Settings › Data) and written under the version of the rules it was redacted by, as a file is: every way in ends in one format and one writer ([importing a file](importing.md) describes the format). Your workspace's AI signature, if set, marks the answers that carry it as your AI's. Two source names are reserved: a key cannot be called csv or import, because those are what uploaded files are stored as.
Feedback
Optional, and the server-side twin of the widget's FunctioningHQ('feedback'): what the customer said about your agent's answer, for a conversation this source already sent (or sends in the same batch, ahead of it).
curl -X POST https://functioninghq.com/api/signals \
-H "Authorization: Bearer sa_4f2b9c1ea87d0356_kZ3n..." \
-H "Content-Type: application/json" \
-d '{
"feedback": [
{ "conversationId": "conv_123", "kind": "rating", "rating": "down", "text": "Wrong plan" },
{ "traceId": "4bf92f3577b34da6a3ce929d0e0e4736", "kind": "escalated" }
]
}'
| Field | Required | What it is |
|---|---|---|
conversationId | one of the two | Your id for the conversation, as this source sent it. |
traceId | one of the two | The OpenTelemetry trace id of the answer it is about, from the last thirty days. |
kind | yes | rating, not_helpful, escalated, copied, source_opened or comment. |
rating | for a rating | up, down, or a whole number from 1 to 5. A thumb is five or one. |
text | no | What the person wrote. Redacted before it is stored. Required for comment. |
url | no | For source_opened. Counted, never kept. |
at | no | ISO 8601. Defaults to when it arrived. |
A rating is the rating of the AI's answer (rating.ai above) and is a low rating at two or under; not_helpful counts against the answer like a failed one; escalated is recorded as your agent handing the conversation to a person, your claim; comment is kept, redacted, beside the rating; copied and source_opened are counted on the conversation. At most 500 in one request. Feedback naming a conversation this source has not sent stores nothing and comes back under feedback.unknown with its index: send it again once the conversation has gone. The response's feedback says what was received, recorded, unknown and rejected.
The response
{
"source": "acme-helper",
"received": 3,
"added": 2,
"updated": 1,
"duplicate": 0,
"rejected": [],
"events": {
"received": 1,
"added": 1,
"duplicate": 0,
"rejected": []
}
}
| Field | Meaning |
|---|---|
added | Conversations this workspace had not seen. |
updated | Ids already held whose content had changed since last time. |
duplicate | Ids already held, unchanged. |
rejected | Entries that did not describe a conversation, each with its id and the reason. |
events | The same four counts for outside-world events. A retry with the same event id is duplicate; one carrying a new endsAt or note updates the event it names, so an incident sent open and again once resolved closes. Its kind and start stay the first sender's. |
Sending the same thing twice is safe
Deduplication is by your id, namespaced to your source, and it is the property to rely on when a request times out or a job replays a day: re-sending a conversation updates it if it changed and counts as a duplicate if it did not. It never creates a second one. That matters because problems are counted by people, and a double-counted conversation is a double-counted person.
Re-send freely. The honest way to run a backfill is to replay the whole history and let duplicate climb.
Errors
| Status | Body error | What to do |
|---|---|---|
| 401 | unauthorized | The key is missing, malformed, unknown or revoked. All four answer the same; check the key you were issued. |
| 400 | bad_request | The body is not JSON, or has no conversations array. |
| 413 | too_large | More than 500 conversations or 4 MB. Split the batch. |
| 422 | — | Every entry was rejected; rejected says why for each. |
| 500 | ingest_failed | Nothing was stored. Retry — re-sending is safe. |
A partially-accepted batch returns 200 with the accepted counts and a populated rejected list. Fix those entries and send them again; the accepted ones will come back as duplicate.
Your own agent, by OpenTelemetry
If your agent already emits OpenTelemetry — the GenAI semantic conventions, or the Vercel AI SDK's experimental_telemetry — point its exporter here instead of writing to the API above. One endpoint, the same key, the same ingest:
OTEL_EXPORTER_OTLP_ENDPOINT=https://functioninghq.com/api/otlp
OTEL_EXPORTER_OTLP_HEADERS="Authorization=Bearer sa_4f2b9c1ea87d0356_kZ3n..."
OTLP/HTTP in either encoding — protobuf, which most SDKs send by default, or http/json — gzipped or not. The answer comes back in the encoding you sent.
- Name the conversation on every call:
gen_ai.conversation.id, or with the AI SDK,experimental_telemetry: { isEnabled: true, metadata: { conversationId, userId } }. A trace that names none is not stored, and the response's partial success says how many spans were left out and why — otherwise every message would be a conversation of its own. - The person comes from
enduser.idoruser.id(or the AI SDK'suserIdmetadata), anduser.emailwhere you send one. Hashed, never stored. - The newest call is the conversation. A chat model is handed the whole history on every call, so its input messages and its output are the transcript. System prompts are left out.
- Tools are kept by name with whether their span ended in error — never their arguments or results, which are not read at all.
- Retrieved passages are read from the conventions your instrumentation already follows, in the same trace as the call: OpenInference's flattened
retrieval.documents.<n>.document.id,.contentand.metadata(LangChain, LlamaIndex and most frameworks emit these through their instrumentors), the GenAI conventions'gen_ai.retrieval.documents, and the output of a span whose kind says it is a retriever (openinference.span.kind,langsmith.span.kindortraceloop.span.kindofretriever), as a list of documents withpage_contentandmetadata. A web address in the metadata'ssourceorurlis the passage's address; anything else there names the article. Or setfunctioninghq.retrievedon the call's span to a JSON list of{ "articleId", "url", "passage" }. A retriever's query and a tool span's input and output are never read. - Feedback (above) rides on a span or on a span event named
functioninghq.feedback, withfunctioninghq.feedback.kind,functioninghq.feedback.rating,functioninghq.feedback.text,functioninghq.feedback.url, andfunctioninghq.feedback.trace_id— the trace of the answer it is about, when the feedback is sent on a trace of its own. The conversation is named as for any span. OpenTelemetry's GenAI conventions describe an evaluator's score of an output, not the customer's own word about it, so these are ours. Every trace a conversation's spans arrive on is kept with it, so feedback naming any of them joins it. Feedback whose conversation has not arrived is counted in the partial success with the reason, since an exporter does not send a span twice: export the conversation first, or send the feedback to/api/signals.
// After the person presses thumbs down, on the answer's own span or a new one
span.addEvent('functioninghq.feedback', {
'gen_ai.conversation.id': conversationId,
'functioninghq.feedback.kind': 'rating',
'functioninghq.feedback.rating': 'down',
})
A conversation sent this way is open until it goes quiet, so it is read once rather than after every request.
Any webhook, in its own shape
A tool that can only post its own JSON — a helpdesk we have no connection for, a form, an automation in Zapier, Make or n8n — can still be a source. On Settings › Sources, open a signals key's Take a webhook in its own shape and say where each field is, as a path: ticket.id, ticket.comments, body, author.type. Say which author values mean your AI and which mean your team; anything else is the customer. Paste a sample to see what it becomes before anything is sent. Then post to:
curl https://functioninghq.com/api/signals/hook \
-H "Authorization: Bearer sa_4f2b9c1ea87d0356_kZ3n..." \
-H "Content-Type: application/json" \
-d '{ "ticket": { "id": 9182, "comments": [ { "body": "My invoice is wrong.", "author": { "type": "end-user" } } ] } }'
A tool that cannot set a header may put the key in the address as ?key=. Paths are picks, never expressions. Times may be ISO 8601 or Unix seconds or milliseconds. With no messages list, each delivery is a conversation of one message from the customer — a form, say — so give each its own id; to send a thread, map its list of messages and send the whole thread each time. A delivery is dated by the field you map for when it changed, else its newest message, else when it arrived, so a thread that grows is stored as it grows. What could not be read is answered with the reason and the rest is stored; a key with no mapping is answered 409 not_mapped.
Receivers: PostHog, Sentry and your status page
Several providers already send events, errors, incidents and deploys on their own. A receiver is the address each is pasted into, so connecting them is a URL rather than code. Connect any of them under Settings › Sources › Product events and errors: the address is shown once, with the key inside it, because a Sentry webhook cannot send a header.
https://app.example.com/api/receivers/posthog/sar_4f2b9c1ea87d0356_kZ3n...
https://app.example.com/api/receivers/sentry/sar_9a01c3e5b7d92f40_Q8vx...
https://app.example.com/api/receivers/status/sar_1c77b2d0fe64a938_Lm5t...
https://app.example.com/api/receivers/deploy/sar_7e3a90c1d4b25f68_Hq2w...
A receiver key (sar_…) is accepted only at its own provider's address. It is refused at /api/signals, /api/signals/email and the widget, and any other key is refused at a receiver. Like every signal key it adds rows to one workspace and nothing else: it cannot read back, start a play, or reach PostHog or Sentry. Disconnecting revokes it; a new address is a new key.
PostHog
In PostHog, open Data pipelines, add an HTTP Webhook destination, paste the address as its URL, and filter it to the events worth sending (the list on Sources suggests them). The default body template is what is read:
{ "event": "{event}", "person": "{person}" }
| PostHog sends | Becomes |
|---|---|
event.uuid | The row's id. A redelivery of the same uuid is a duplicate. |
event.event | A productEvent with that name (facets.event). |
event.timestamp | When it happened. |
event.properties.$current_url | facets.url, without its query or fragment. |
event.url or person.url | facets.posthog, a link on the evidence. |
event.distinct_id | A hashed alias in PostHog's own namespace. |
person.properties.email (or $set.email) | A hashed email alias, which is how the event joins the person a helpdesk or email already knows. |
Events whose names start with $ are PostHog's own automatic capture and are ignored, and the response says so. Once the workspace has saved its list of events worth sending (Sources, beside the receivers, at most eight, suggested from its own patterns and requests), an event not on it is ignored too. An event on the list is context on the people who sent it and a count of people who reached it; it is never charted. $identify stores no row: its distinct_id, $anon_distinct_id and email are asserted together, so the anonymous device and the signed-in person become one.
Sentry
In Sentry, enable the WebHooks integration for the project, paste the address as a callback URL, and add Send a notification via WebHooks to an issue alert. An integration app's issue alert (data.event) is read too.
| Sentry sends | Becomes |
|---|---|
the issue id and the triggering event_id | The row's id, <issue>:<event>. The same alert redelivered is a duplicate; the issue firing for another event is a new row. |
title (or message) and culprit | An errorReport reading title (culprit). |
| the issue URL | facets.sentry, without the referrer query. |
contexts.replay.replay_id or the replayId tag | facets.replay, the replay's page. |
level | facets.level. |
user.id, user.email | Hashed aliases; the id in Sentry's own namespace. |
Your status page
An incident is precisely the thing that explains a spike, and until there was a receiver for it the product asked somebody to remember to type one in while it was happening. In Statuspage, Instatus or Better Stack, add a webhook subscriber and paste the address. Nothing else is needed.
| Your status page sends | Becomes |
|---|---|
| the incident id | The row's id. The same incident redelivered updates the one row rather than opening a second. |
created_at, started or started_at | When the window opens. |
resolved_at or resolved | When it closes. Without one the window stays open, because guessing when it ended would be guessing which numbers it touched. |
| the incident's name | The note on it, redacted like every other string you send. |
It becomes a context event of kind incident, on the same axis as a release or a holiday: every measurement whose window it touches carries it as a caveat, and a spike of findings inside one does not become a documentation fix (incidentDriven). It joins nobody — an incident is about a window, not about a person — and nothing is read from or written to your status page: sending us signals is never permission to act on the system that sent them.
The response counts incidents apart from conversations, as events and eventsDuplicate, because adding the two would make a status page look like a source of support volume.
Or let us read it. Under Settings › Sources › Where you post incidents and releases, paste the page people visit — a status page or a changelog — and it is read once a night, one request, from its feed (Statuspage's own incident list, or the RSS or Atom feed nearly every status vendor and changelog tool publishes; a changelog that is only a page is read for its dated entries, keeping only the ones whose title and date are written on it). Each entry becomes an event as above, and its text becomes knowledge grading can cite as it stood when an answer was given, near its own date and nowhere else. Nothing is read from a site other than the one you pasted, and nothing is read while the workspace is paused.
What a receiver keeps
The identifiers above are hashed with the workspace's salt in the request itself and discarded; no distinct id, user id, email or IP address is stored or logged. Event properties other than the page are not read. A provider's id for a person is never assumed to be your product's user id: it joins a person only through an identifier the same delivery carried.
The response is 200 whenever the body was JSON, with added, duplicate, ignored and rejected counts, because a provider that sees a 4xx for a payload it will keep sending disables the destination. 401 is a missing or unknown key, 403 a key for another receiver, 413 a body over 1 MB.
Deploys and releases
A team that fixes its own agent fixes it in code, and the fix goes live when it deploys. Paste the address into Vercel (a webhook for deployment.succeeded) or GitHub (a webhook for releases, or for deployment statuses), or both.
| Arrives | Becomes |
|---|---|
Vercel deployment.succeeded with target: production | A release event at the deployment's time, its note naming the project and the commit (githubCommitSha, shortened). A preview deploy is ignored. |
A GitHub release with action: published | A release event at published_at, its note naming the tag. |
A GitHub deployment status of success in production | A release event at its time, its note naming the commit. |
Anything else — a GitHub ping, a draft release, a failed deploy — is accepted and ignored with the reason. It joins nobody, and nothing about who deployed is read. A fix recorded with record_fix and the commit it shipped can then be found on the timeline where it went live.
Inbound email
If your support is an email address, forward inbound mail to POST /api/signals/email instead — same key, one message per request.
curl -X POST https://app.example.com/api/signals/email \
-H "Authorization: Bearer sa_4f2b9c1ea87d0356_kZ3n..." \
-H "Content-Type: application/json" \
-d '{
"messageId": "<CADnw=1@mail.acme.test>",
"threadId": "thread-4417",
"from": { "email": "dana@acme.test", "name": "Dana" },
"subject": "Cannot add a seat",
"text": "I cannot add a second seat to our plan.",
"receivedAt": "2026-09-09T09:12:00Z",
"headers": { "auto-submitted": "no" }
}'
threadId is what makes a reply part of the same conversation instead of a new person with a new problem — send your provider's thread or references id wherever you have one. Quoted history beneath a reply is dropped, so a thread does not accumulate ten copies of the first message, and a trailing -- signature is left off.
Automatic mail is accepted and ignored rather than refused: vacation responders, bounces from mailer-daemon and anything carrying auto-submitted, precedence: bulk or a list-id header. The response says "ignored": "automatic" so you can see it happened. Refusing them would only make a provider retry.
Set "outbound": true on a message your team sent, so the transcript reads as the exchange it was.
Documentation
A workspace whose documentation is a website or a public GitHub repository rather than a help center can have it read into the knowledge base, so correctness verdicts have something to quote. Paste the address under Settings › Sources › Point us at your docs, or run:
npm run signals:crawl -- --id <tenantId> --url https://acme.test/docs
npm run signals:crawl -- --id <tenantId> --url https://github.com/acme/docs/tree/main/docs --site https://docs.acme.test
A website is read from what it publishes for machines before its HTML. On the address's own host — in the section you gave, then at the root — it looks for, in this order:
llms-full.txt, the whole documentation as one Markdown file. Each article must say where it came from (aSource:line under its heading, orsource:orurl:in front matter above it), because that address is how the article is known from one read to the next.llms.txt, an index of links, usually to each page's Markdown. Furtherllms.txtindexes it links to (as ReadMe publishes per section) are followed.sitemap.xml, or a sitemap index and the sitemaps it names on the same host.- Otherwise, links followed from the address through HTML, as before.
The first that yields a page worth quoting is the one used, and Settings › Sources says which it was. A page from an index or a sitemap is asked for as Markdown first (Accept: text/markdown), and where the site serves a .md copy of its pages (/guides/seats.md for /guides/seats) that is read instead of the HTML. An article is stored under its page's address, not the .md, so a link opens a page a reader can see and a later read through HTML lands on the same article. ReadMe, Mintlify, GitBook, Docusaurus and Nextra sites usually publish at least one of these.
A public GitHub repository is read from the Markdown (.md, .mdx) files in the folder you give, through GitHub's public API and its raw file host, without signing in — so only a public repository on github.com can be read, and a private or missing one is refused with the reason. Front matter is stripped and the title taken from it, or from the first heading. Each file links to itself on GitHub unless you also give the docs site it is published at, in which case each links to its page there (docs/guides/seats.md becomes https://docs.acme.test/guides/seats). Folders starting with _ or . are partials and configuration, and are skipped.
Every route keeps the same bounds. It reads only an https address on the public internet and never leaves the address's host; a redirect is followed only inside the section (or, for the machine files, the same host). Each request has ten seconds and stops reading at its size cap — 4 MB for llms-full.txt, past which the last, cut-off article is dropped. It obeys one page budget, whichever route, and asks at most two requests per page kept. It stores each page as a knowledge-base version — an unchanged page keeps its version, so citations written months ago still resolve to the text they quoted. It is read once when asked, and again weekly only if you turn that on; it is never a nightly job.
Pull requests to your docs repository
Reading a public repository needs no sign-in. A play can also open a pull request there, with the exact Markdown a person on your team approved, once you give it write access under Settings › Sources, beside the repository's row. Make a fine-grained personal access token on GitHub with Only select repositories set to that one repository, and Contents and Pull requests set to read and write; nothing else. A classic token is refused, because it reaches every repository its owner can. It is checked with one read, stored encrypted, and used for nothing but these pull requests.
What a play does with it, every time:
- Looks for a pull request already opened from the play's branch (
functioninghq/docs-<id>, one per approved version). If there is one, open, closed or merged, that is the answer and nothing is written. - Reads the file on your base branch — the branch in the repository address you gave, else the repository's default. A new page must not already exist there. An edit must find the file exactly as it was when the person approved it; if it changed since, nothing is written and the play says why.
- Makes the branch from the base, writes the one file on it, and opens the pull request into the base, with a description saying a person approved the file and listing anything they were asked to confirm.
It never pushes to the base branch and never merges: the docs change when somebody on your team merges the pull request. A new page is written as <folder>/<title-as-a-slug>.md with a title in its front matter; an edit keeps the file's own front matter and replaces the text below it. A file that uses MDX components, imports or comments is never rewritten, because the text read from it has them taken out. The play's step records the pull request's number and address. If GitHub stops answering after a write has left, the step waits for a person to say whether it happened rather than trying again.
What you get back out
Nothing from this endpoint — it only accepts. What the signals become is visible in the app: conversations appear in the list, failures become findings, findings are grouped into problems counted by people, and an experiment against a problem is measured on the same metrics as any other source. A source's coverage — when it last sent, and how far behind it is — is shown under Connections.
Sentry, PostHog and session-replay URLs sent as facets.sentry, facets.replay or facets.posthog (https only) appear as links on the problem's evidence.
Examples and a small SDK
Copy-paste JSON for a chat, an email thread, a thumbs rating, a form, a product event and an error report lives in [examples/signals](../examples/signals). The same shapes as functions — chatTranscript, emailThread, thumbsRating, formSubmission, productEvent, errorReport, postSignals — are src/lib/signals/sdk.ts.
Something missing, or a field that does not behave as this says? Tell us — the contracts here are what the code is held to, so a page that is wrong is a bug in the same sense the code would be.