fde-framework 0.1.0__py3-none-any.whl

fde/framework/approaches/ocr-pipeline.md

@@ -0,0 +1,13 @@
+---
+id: ocr-pipeline
+name: OCR pipeline
+complexity: 2
+components: [perception]
+applies_when: [input_format == scanned_documents, input_format == images]
+avoid_when: [input_format == structured_data, input_format == text]
+evidence: {case_ids: [structured-extraction], confidence: medium, last_verified: 2026-08-21}
+---
+Pixels to text, with everything that implies: confidence per character, layout
+inference, and a per-page error rate that becomes the system's ceiling.
+
+Measure that rate before promising anything downstream of it.

fde/framework/approaches/optimisation-reasoning.md

@@ -0,0 +1,30 @@
+---
+id: optimisation-reasoning
+name: Constraint optimisation as the decision-maker
+complexity: 1
+components: [reasoning]
+applies_when: [output_shape == decision]
+avoid_when:
+  - output_shape == freeform
+  - output_shape == structured
+  - output_shape == classification
+  - output_shape == decision and labelled_count >= 1000
+evidence: {case_ids: [route-planning], confidence: high, last_verified: 2026-08-31}
+---
+A solver as the reasoner, for decisions that are genuinely assignments under
+constraints: crew to flights, loads to routes, stock to stores. Declared
+constraints, an objective, and an answer that is optimal against what was
+declared -- with the standing caveat that it is exactly as good as the
+declarations.
+
+The avoid rule is the finding from a factory-floor engagement: a per-item
+decision that history has already labelled thousands of times is a
+classification wearing a decision's name. Twelve thousand pass-or-repair
+labels are not constraints to satisfy, they are a function to learn, and a
+solver given that job has nothing to optimise. Where the labels exist, the
+learned model wins; where the decision is an allocation nobody has ever
+labelled, the solver does.
+
+Split from the planning-side optimisation on purpose: an airline recovery
+plan and a per-unit disposition share an algorithm family and nothing else,
+and one avoid rule serving both components punished the wrong one.

fde/framework/approaches/optimisation.md

@@ -0,0 +1,19 @@
+---
+id: optimisation
+name: Optimisation
+complexity: 1
+components: [planning]
+applies_when: [output_shape == decision]
+avoid_when: [output_shape == freeform, output_shape == structured, output_shape == classification]
+evidence: {case_ids: [route-planning], confidence: high, last_verified: 2026-08-21}
+---
+Constraint solvers and mathematical programming.
+
+**Optimisation makes decisions; machine learning makes predictions.** Where the
+problem is to allocate, schedule, route or select subject to hard constraints, a
+solver answers it exactly and proves the answer feasible. A model trained to
+imitate past decisions will produce something plausible that violates a
+constraint, and will not tell you it did.
+
+The two combine well -- predict demand, then optimise against it -- but the
+prediction is not the decision.

fde/framework/approaches/passthrough.md

@@ -0,0 +1,11 @@
+---
+id: passthrough
+name: Pass through
+complexity: 0
+components: [perception]
+applies_when: [input_format == structured_data]
+avoid_when: [input_format == scanned_documents, input_format == documents, input_format == images]
+evidence: {case_ids: [churn-scoring], confidence: high, last_verified: 2026-08-21}
+---
+Data that already has a schema needs validating, not parsing. The cheapest
+perception is none.

fde/framework/approaches/role-scoped-authority.md

@@ -0,0 +1,19 @@
+---
+id: role-scoped-authority
+name: Role-scoped authority
+complexity: 2
+components: [governance]
+applies_when: [access_model == role_based]
+avoid_when: [access_model == single_operator, access_model == open_internal]
+evidence: {case_ids: [structured-extraction], confidence: medium, last_verified: 2026-08-30}
+---
+Approval and audit that know which role is speaking.
+
+The approval gate refuses an approval that does not carry an approver role,
+and the audit records the role beside the person. Entitlements remain an
+intersection -- what the delegating person may do, what the agent is scoped
+to, what the tool requires -- with the role as a ceiling on the first term,
+never an extension of it.
+
+The roles themselves are client content: this approach fixes the contract
+that a role must be named, and refuses to invent the names.

fde/framework/approaches/segmentation.md

@@ -0,0 +1,29 @@
+---
+id: segmentation
+name: Segmentation
+complexity: 1
+components: [representation]
+applies_when: [output_shape == freeform]
+avoid_when: [output_shape == structured]
+evidence: {case_ids: [studio-style], confidence: medium, last_verified: 2026-08-28}
+---
+Documents into retrievable chunks, with their origins attached.
+
+The representation a freeform system actually needs: not fields onto a
+contract but a corpus cut into pieces a retriever can rank -- windows sized
+for the questions people ask, overlapping so answers that straddle a cut are
+not lost, each chunk carrying its source and offsets so every generated
+sentence can point back at where it came from.
+
+Traceability is the non-negotiable half. A chunk that cannot say where it
+came from produces answers that cannot be checked, and an unverifiable
+answer from a system inside a client's environment is a liability wearing a
+feature's clothes.
+
+Boring on purpose. Semantic and layout-aware splitting are graduations to
+earn with measured retrieval quality, not defaults -- fixed windows with
+overlap are the rung that ships this week and measures honestly.
+
+Avoided for structured output: chunking an extraction corpus buries
+the fields the contract needs under retrieval units nobody asked for --
+that shape wants a mapper.

fde/framework/approaches/self-hosted.md

@@ -0,0 +1,38 @@
+---
+id: self-hosted
+name: Self-hosted
+complexity: 2
+components: [serving]
+applies_when:
+  - data_residency == cannot_leave
+  - hosting == air-gapped
+  - hosting == on-prem
+  - hosting == hybrid
+  - latency_budget_ms < 100
+avoid_when:
+  - operates_after_handover == nobody_yet
+  - accelerator == none and human_waiting == yes
+evidence: {case_ids: [structured-extraction], confidence: high, last_verified: 2026-08-21}
+---
+Open weights on hardware you control.
+
+Chosen because something forbids the alternative, not because it is cheaper --
+at sustained interactive load it usually is not, once redundancy, peak headroom
+and prefill overhead are counted. Naive sizing understates the fleet
+substantially: a replica is however many devices the weights and cache need
+together, and pricing each replica as one device quotes a large model's fleet
+at a fraction of its cost.
+
+When the hardware will not hold the model, three levers in order:
+quantisation, then parameter-efficient adaptation, then distillation. Each costs
+more effort and more quality risk than the one before, so stop at the first that
+fits.
+
+Serving stacks cache at four layers that share one word and nothing else: the
+KV cache lives for one request, prefix caching keeps those tensors across
+requests on the server, provider prompt caching is the same idea on somebody
+else's hardware, and a semantic cache stores whole responses by similarity.
+The first three hit only on exact token identity, which is why sticky routing
+matters on a self-hosted fleet -- a request that lands on a replica holding
+its prefix skips the prefill that dominates time-to-first-token -- and why a
+model switch is a cache reset: entries are keyed to the model that made them.

fde/framework/approaches/serverless-gpu.md

@@ -0,0 +1,27 @@
+---
+id: serverless-gpu
+name: Serverless GPU
+complexity: 1
+components: [serving]
+applies_when:
+  - human_waiting == no
+  - availability_target == best_effort and human_waiting != yes
+avoid_when:
+  - human_waiting == yes
+  - data_residency == cannot_leave
+  - hosting == air-gapped
+  - latency_budget_ms < 100
+evidence: {case_ids: [studio-style], confidence: medium, last_verified: 2026-08-21}
+---
+Rented GPUs that scale to zero between jobs.
+
+A stated best-effort availability target is the same permission granted in
+different words: downtime and cold starts are acceptable, so paying for a
+warm fleet is paying for a promise nobody asked for.
+
+The right answer when nobody is waiting: a multi-minute cold start is an
+infrastructure detail rather than a user-experience failure, and paying nothing
+between runs beats per-token pricing at volume by a wide margin.
+
+The trap is idle time. A fleet left running overnight costs more than the work
+it did, so scale-to-zero has to be real rather than nominal.

fde/framework/approaches/speech-transcription.md

@@ -0,0 +1,21 @@
+---
+id: speech-transcription
+name: Speech transcription
+complexity: 1
+components: [perception]
+applies_when: [input_format == audio]
+avoid_when: [input_format == documents, input_format == structured_data, input_format == text]
+evidence: {case_ids: [structured-extraction], confidence: medium, last_verified: 2026-09-01}
+---
+Voice to text, before anything downstream reasons about it.
+
+**The word error rate is this modality's version of the OCR ceiling**: no
+later component recovers a word that was never heard, and a system quoting
+end-to-end accuracy above its transcription accuracy is quoting a number
+that cannot exist. Measure it on the client's own audio -- accents, lines,
+handsets -- never on a benchmark's studio recordings.
+
+Where the callers speak several languages, the transcription model is the
+first place that requirement lands, and per-language error rates belong in
+the acceptance protocol -- an average across languages hides exactly the
+population the service was built to reach.

fde/framework/approaches/structured-logs.md

@@ -0,0 +1,11 @@
+---
+id: structured-logs
+name: Structured logs
+complexity: 0
+components: [observability]
+applies_when: [always]
+avoid_when: [external_systems > 1]
+evidence: {case_ids: [churn-scoring], confidence: high, last_verified: 2026-08-21}
+---
+Machine-readable events with correlation identifiers. Enough for a pipeline
+whose path you can enumerate.

fde/framework/approaches/systemd-unit.md

@@ -0,0 +1,30 @@
+---
+id: systemd-unit
+name: Service unit
+complexity: 0
+components: [deployment]
+applies_when: [always]
+avoid_when:
+  - existing_cluster == true
+  - container_competence == true
+evidence: {case_ids: [structured-extraction], confidence: high, last_verified: 2026-08-25}
+---
+A virtual environment and a service unit. No container, no orchestrator, no
+registry.
+
+The floor of the ladder, so this is what nothing-known resolves to: it is the
+rung that costs least if it turns out to be wrong, and every rung above it has
+to be earned by something in the profile.
+
+Being the floor means never being ruled out by workload shape. Many external
+integrations strain a single service unit -- worth saying in the design -- but
+a team with no cluster and no container practice still needs to deploy, and a
+floor that can be knocked out leaves that team with nothing at all.
+
+Rung zero, and frequently the correct answer rather than the lesser one. For a
+single-node deployment serving one thing, this is understood by everyone who has
+ever administered a Linux box, restarts on failure, starts on boot, and adds
+nothing anybody has to learn.
+
+Reaching past it costs a competency the team may not have and a platform
+somebody has to keep patched. That cost is real and is paid every month.

fde/framework/approaches/terraform-module.md

@@ -0,0 +1,22 @@
+---
+id: terraform-module
+name: Declarative provisioning
+complexity: 1
+components: [provisioning]
+applies_when: [provisioning_api == true, environment_lifetime == ephemeral]
+avoid_when:
+  - provisioning_api == false
+  - existing_cluster == true
+  - existing_iac_tool == ansible
+evidence: {case_ids: [studio-style], confidence: high, last_verified: 2026-08-25}
+---
+Resources declared, with state tracked so they can be destroyed again.
+
+The one capability a convergence tool does not have: it knows what it created,
+so it can show drift and take it all away. That matters for environments that
+must vanish -- per-branch, per-pilot, per-demo -- and is bookkeeping for a cluster
+that lives five years.
+
+Ruled out where the team runs something else, because the tool they cannot
+maintain is the one that rots. And ruled out on bare metal, where there is no
+API to call and the state file would track nothing.

fde/framework/approaches/text-extraction.md

@@ -0,0 +1,14 @@
+---
+id: text-extraction
+name: Text extraction
+complexity: 1
+components: [perception]
+applies_when: [input_format == documents, input_format == text]
+avoid_when: [input_format == scanned_documents, input_format == structured_data]
+evidence: {case_ids: [structured-extraction], confidence: high, last_verified: 2026-08-21}
+---
+Pulling text and layout out of documents that already carry a text layer.
+
+Where the ceiling gets set. Tables are the usual casualty: a table flattened
+into a line of numbers has lost the relationship between them, and nothing
+downstream puts it back.

fde/framework/approaches/traced.md

@@ -0,0 +1,24 @@
+---
+id: traced
+name: Distributed tracing
+complexity: 1
+components: [observability]
+applies_when: [always]
+avoid_when: [external_systems < 2]
+evidence: {case_ids: [studio-style], confidence: high, last_verified: 2026-08-21}
+---
+One system with an enumerable path does not need spans across it; structured
+logs answer the same questions for less. Past that, spans across the whole path, with cost and latency attributed per tenant.
+
+A loop cannot be debugged one node at a time. You need the trajectory: what it
+decided, in what order, and why it stopped -- which is precisely what a log line
+per step cannot tell you.
+
+Per-tenant cost attribution is an architectural decision rather than a reporting
+one. Retrofitting it means touching every call site.
+
+The GenAI semantic conventions are **not stable**: every attribute still carries
+development status, and they moved to their own repository on their own release
+cadence in mid-2026 -- a separate cadence, not a graduation. Chat and embedding
+attributes are settled enough to build on; agent and tool-orchestration ones are
+still moving. Use them, pin the version, and expect a rename to arrive as work.

fde/framework/approaches/vector-search.md

@@ -0,0 +1,17 @@
+---
+id: vector-search
+name: Vector search
+complexity: 1
+components: [retrieval]
+applies_when: [query_pattern == lookup, query_pattern == comparative]
+avoid_when: [query_pattern == multi_hop]
+evidence: {case_ids: [studio-style], confidence: high, last_verified: 2026-08-21}
+---
+Similarity over embeddings, usually with a reranker in front of the results.
+
+Reranking is the cheapest quality gain available in most pipelines and the one
+most often skipped: single-digit point lifts for a couple of hundred
+milliseconds, without touching the index.
+
+The embedding model is the least reversible choice in the system, since changing
+it means reindexing everything. Decide it late.

fde/framework/approaches/video-ingestion.md

@@ -0,0 +1,16 @@
+---
+id: video-ingestion
+name: Video ingestion
+complexity: 2
+components: [perception]
+applies_when: [input_format == video]
+avoid_when: [input_format == documents, input_format == structured_data, input_format == text]
+evidence: {case_ids: [structured-extraction], confidence: low, last_verified: 2026-09-01}
+---
+Frames sampled from footage, timestamped, and handed on as images -- video
+perception is image perception plus the decision of which moments to look at.
+
+Complexity 2 because the sampling policy is a real design surface: too
+sparse misses the event, too dense drowns the pipeline, and the honest
+starting point is event-triggered sampling around whatever the stream layer
+flags rather than a fixed frame rate nobody can justify.

fde/framework/approaches/windowed-ingestion.md

@@ -0,0 +1,25 @@
+---
+id: windowed-ingestion
+name: Windowed ingestion
+complexity: 1
+components: [perception]
+applies_when: [input_format == streams]
+avoid_when: [input_format == documents, input_format == scanned_documents]
+evidence: {case_ids: [route-planning], confidence: medium, last_verified: 2026-08-28}
+---
+A stream into bounded batches, because nothing downstream reasons over an
+infinity.
+
+Perception for input that never ends: consume, window by count or by time
+(whichever closes first), stamp each window with what it saw and when, and
+hand finite batches to the pipeline. The window is the unit of everything
+downstream -- of retry, of idempotency, of evaluation -- so its identity is
+stable and its boundaries are recorded.
+
+Late data is the design decision, not an edge case: a watermark says how
+long a window waits, and what arrives later lands in a correction window
+rather than mutating a closed one. Reprocessing a closed window is how the
+same event gets acted on twice.
+
+Avoided for finite corpora: documents want batch ingestion with a
+known end, and watermarks on a corpus that does not move are ceremony.

fde/framework/approaches/working-state.md

@@ -0,0 +1,13 @@
+---
+id: working-state
+name: Working state
+complexity: 0
+components: [memory]
+applies_when: [recall_span == within_session, recall_span == within_turn]
+avoid_when: [recall_span == across_sessions]
+evidence: {case_ids: [studio-style], confidence: high, last_verified: 2026-08-21}
+---
+Context held for the length of a session and then discarded.
+
+Cheap, and it fails safely: a mistake in working state disappears when the
+session ends. Nothing here is a decision anyone has to live with.

fde/framework/cases/churn-scoring.md

@@ -0,0 +1,45 @@
+---
+id: churn-scoring
+profile:
+  output_shape: classification
+  corpus_size: 2000000
+  labelled_count: 50000
+  interpretability_required: true
+  latency_budget_ms: 10
+  data_residency: cannot_leave
+  hosting: customer-vpc
+  human_waiting: "yes"
+decisions:
+  representation: classical-ml
+  evaluation: labelled-metrics
+  serving: self-hosted
+  accountability: explainability-record
+  governance: boundary-and-audit
+  observability: structured-logs
+  deployment: systemd-unit
+  provisioning: manual-runbook
+outcome: >-
+  The shape holds in public production reports: gradient-boosted
+  classification beating LLM approaches on cost and accuracy for narrow
+  tabular tasks (Arelion/DeLaval: 97% accuracy, 80% manual-workload
+  reduction, publicly reported; Airtrain: 47% to 94% accuracy with 94%
+  cost reduction after moving to fine-tuned small/classical models,
+  publicly reported).
+sanitization: reviewed
+---
+An engagement shape assembled from publicly documented production
+case studies. No client of ours is identifiable from it, and none
+contributed to it.
+
+Tabular classification with an interpretability obligation and a
+millisecond budget. Assembled from publicly documented deployments where
+classical machine learning beat generative approaches in-domain --
+Arelion/DeLaval's XGBoost classification and Airtrain's published
+accuracy/cost results. The shape that keeps classical ML a first-class
+citizen. No private engagement contributed to this record.
+
+The decisions above are what the engine derives from this profile
+today -- reproducible by running it. The published figures cited in
+the outcome belong to the public record and carry their own dates;
+measured outcomes for engagements run through this framework enter
+only via `fde retro`.

fde/framework/cases/route-planning.md

@@ -0,0 +1,44 @@
+---
+id: route-planning
+profile:
+  output_shape: decision
+  latency_budget_ms: 200
+  external_systems: 4
+  existing_cluster: true
+  container_competence: true
+  data_residency: may_leave
+  hosting: customer-vpc
+  human_waiting: "yes"
+decisions:
+  planning: optimisation
+  reasoning: optimisation
+  evaluation: labelled-metrics
+  integration: governed-tools
+  governance: audit-only
+  observability: traced
+  deployment: kubernetes-manifests
+  provisioning: gitops
+outcome: >-
+  The shape holds in decades of published operations-research practice:
+  constraint solvers producing auditable dispatch decisions at fleet
+  scale (the publicly documented route-optimisation programmes of large
+  logistics operators), with generative models absent from the decision
+  path because a solver's output is provable and a model's is not.
+sanitization: reviewed
+---
+An engagement shape assembled from publicly documented production
+case studies. No client of ours is identifiable from it, and none
+contributed to it.
+
+Constrained dispatch decisions against live operational systems.
+Anchored in the public operations-research record -- large-scale fleet
+route optimisation is among the most documented solver deployments in
+industry -- rather than any private engagement. Optimisation makes
+decisions; machine learning makes predictions; this shape is why the
+solver rung exists and why mutative integrations get gates and keys.
+
+The decisions above are what the engine derives from this profile
+today -- reproducible by running it. The published figures cited in
+the outcome belong to the public record and carry their own dates;
+measured outcomes for engagements run through this framework enter
+only via `fde retro`.

fde/framework/cases/structured-extraction.md

@@ -0,0 +1,48 @@
+---
+id: structured-extraction
+profile:
+  output_shape: structured
+  input_format: scanned_documents
+  corpus_size: 500000
+  labelled_count: 10000
+  data_residency: cannot_leave
+  hosting: on-prem
+  external_systems: 3
+  human_waiting: "yes"
+  operates_after_handover: platform_team
+  container_competence: false
+  existing_cluster: false
+decisions:
+  perception: ocr-pipeline
+  representation: deterministic
+  evaluation: field-match
+  governance: boundary-and-audit
+  integration: governed-tools
+  observability: traced
+  deployment: systemd-unit
+  provisioning: manual-runbook
+outcome: >-
+  The shape holds in public production reports: structured metadata
+  extraction at hundreds of thousands of documents per week with
+  ~99% field accuracy and order-of-magnitude manual-effort reduction
+  (AArete's Doxy AI, publicly reported), and document processing under
+  compliance boundaries on self-managed infrastructure (Deutsche Bank,
+  Anthem Blue Cross, publicly reported).
+sanitization: reviewed
+---
+An engagement shape assembled from publicly documented production
+case studies. No client of ours is identifiable from it, and none
+contributed to it.
+
+High-volume field extraction from scanned documents inside a boundary
+nothing may leave. Assembled from publicly documented production
+deployments -- AArete's structured-extraction platform (500k documents a
+week, 99% accuracy, 97% manual-effort reduction, as published), and the
+compliance-bounded on-premise document systems reported by Deutsche Bank
+and Anthem Blue Cross. No private engagement contributed to this record.
+
+The decisions above are what the engine derives from this profile
+today -- reproducible by running it. The published figures cited in
+the outcome belong to the public record and carry their own dates;
+measured outcomes for engagements run through this framework enter
+only via `fde retro`.

fde/framework/cases/studio-style.md

@@ -0,0 +1,46 @@
+---
+id: studio-style
+profile:
+  output_shape: freeform
+  human_waiting: "no"
+  data_residency: may_leave
+  hosting: customer-vpc
+  corpus_size: 5000
+  container_competence: true
+  existing_cluster: false
+  environment_lifetime: ephemeral
+  provisioning_api: true
+decisions:
+  reasoning: llm
+  serving: managed-api
+  evaluation: judged
+  governance: audit-only
+  observability: structured-logs
+  deployment: compose
+  provisioning: terraform-module
+outcome: >-
+  The shape holds in public production reports: batch generation against
+  managed endpoints where nobody waits on a single answer, with batch
+  processing and prompt engineering cutting cost per unit dramatically
+  (Etsy's buyer-profile generation: 94% cost reduction per million
+  users, publicly reported), and judge-based evaluation calibrated
+  before scores are trusted (DoorDash's guardrail-plus-judge design,
+  publicly reported).
+sanitization: reviewed
+---
+An engagement shape assembled from publicly documented production
+case studies. No client of ours is identifiable from it, and none
+contributed to it.
+
+Open-ended generation in batch, where nobody waits on any single
+answer. Assembled from publicly documented deployments -- Etsy's batch
+profile generation economics and DoorDash's published judge-based
+evaluation design. The shape that exercises the generative path honestly:
+prompted model first, calibrated judge, per-token economics over a held
+fleet. No private engagement contributed to this record.
+
+The decisions above are what the engine derives from this profile
+today -- reproducible by running it. The published figures cited in
+the outcome belong to the public record and carry their own dates;
+measured outcomes for engagements run through this framework enter
+only via `fde retro`.

fde/framework/components/accountability.md

@@ -0,0 +1,20 @@
+---
+id: accountability
+name: Accountability
+caps: []
+pipeline: false
+required_when:
+  - interpretability_required == true
+---
+Being able to say why a particular decision came out the way it did, to somebody
+outside the team, months later.
+
+Separate from governance on purpose. A boundary answers *where data may go*;
+this answers *why this outcome*. They are triggered by different things and a
+system frequently needs both -- a regulated lender has a residency constraint
+and an obligation to explain a refusal, and folding them into one component
+means whichever fires first hides the other.
+
+Built in from the start or not at all. Reconstructing why a model decided
+something after the fact is guesswork wearing a report's formatting, and the
+question always arrives when the original context is gone.

fde/framework/components/deployment.md

@@ -0,0 +1,19 @@
+---
+id: deployment
+name: Deployment
+caps: []
+pipeline: false
+required_when:
+  - always
+---
+How the thing actually runs on a machine.
+
+A ladder rather than a default, from a service unit through to a cluster. Every
+rung is the right answer somewhere, and the failure this exists to prevent is
+reaching past rung zero out of habit: the container runtime is cheap, and the
+platform around it is not -- most of that cost being a team that now has to
+operate something it did not before.
+
+Earn the way rightward. More than one long-lived process earns a container;
+multi-node scheduling or zero-downtime rolling deploys earn an orchestrator; and
+one model on two GPUs earns neither.

fde/framework/components/embedding.md

@@ -0,0 +1,23 @@
+---
+id: embedding
+name: Embedding
+caps: [retrieval, memory]
+required_when:
+  - query_pattern == comparative
+  - query_pattern == multi_hop
+---
+Turning text into vectors, and deciding where that happens.
+
+Caps retrieval and memory alike: a poor embedding sets a ceiling neither a
+reranker nor a better model gets past, because the thing that was not
+represented cannot be retrieved.
+
+**The least reversible decision in a retrieval system.** Changing the model
+means reindexing the entire corpus, so it is made late, with evidence, and after
+the cheaper choices have been settled.
+
+Placement is not a separate question from residency. An embedding is
+recoverable to its source, so computing one through a vendor is sending the
+text -- and a store holding embeddings of regulated data is in scope for the
+boundary. "We only send vectors" is the version of this that sounds safe and
+is not.