Dot Star DX Studio
AI-powered tooling for workforce benefits & group insurance, right inside your editor.
Map, validate, and transform LDEx and any benefits & insurance data without leaving
VS Code, Cursor, or Windsurf. Built for the carriers, benefit administrators,
and brokers modernizing off legacy spreadsheets, EDI, and SOAP.
Dot Star · Activate a license · Contributing
A file comes in. Your partner gets the right file out.
That is the whole job, and DX Studio does it with you, without writing code:
- Map a File. Open Home and choose Map a File to a New Format (or right-click a
file and choose Map This File...). Pick your CSV, Excel, JSON, XML, EDI 834 or
fixed-width file and the format your partner needs, add a sample of their file and any
spec, and AI drafts the mapping. It checks every pass against your sample and fixes what
differs. The Mapping Report shows every field, where it comes from and how sure the
match is.
- Make This a Pipeline. One click saves the mapping as a pipeline, with your file as its
Sample File, so every new file is handled the same way. Test Run shows the result
without sending anything.
- Send a File to a Partner. A short guided setup asks where files arrive, where the
results go and what they are called. Pick one of the files that arrive and DX Studio turns
its dates and counters into a pattern, so tomorrow's file is picked up too.
- Test Delivery. Picks up the matching files without moving them, runs the pipeline and
sends the results to your test destination only.
- Deliver to Production. DX Studio prepares every file and shows it as Ready to Send,
with its final name and where it goes, before anything leaves your computer.
The Get Started with DX Studio walkthrough follows the same steps.
Why Dot Star DX Studio
Benefits and group-insurance integration is still done in spreadsheets, hand-written EDI,
and brittle SOAP. Dot Star DX Studio brings a modern, AI-assisted data-mapping workflow to
the editor your team already uses, purpose-built for LDEx and benefits/insurance data.
Features
✦ Draft a mapping with AI
Right-click a source file and choose Map This File..., or start from the Home panel. Hand
the wizard a sample of the output you want, plus any mapping spec, record layout, or value
maps you have, and the AI drafts the mapping for you. It checks every pass against your sample
field by field (and LDEx output against the standard), fixes exactly what differs, and on
multi-record layouts can ask you which source column to use instead of guessing.
✦ Pipelines that pick up and deliver
Chain a mapping and rules steps (Add Data, Check for Issues, Route) into a runnable pipeline. The story-flow Pipeline Builder reads top to bottom: an Input card
(Sample File, Whole Folder or Pick Up), the steps, and an Output card
(Results Only, Output Folder or Deliver To). Pipelines pick files up from a shared
folder or SFTP server, name each result the way your partner expects, and deliver it, with a
Test Delivery before every Deliver to Production. Set Up a Delivery fills it all in
from a few questions.
✦ Fixed-width output + Record Layout Editor
Write carrier-style fixed-width files as well as JSON, CSV, and LDEx. Record layouts (field
names, positions, widths, padding) live in _layouts.json and open in a visual Record Layout
Editor.
✦ Business-friendly editors & reports
Edit value maps and rule variables in visual table editors instead of raw JSON, and read a per-field
Mapping Report (confidence, source, and review flags) instead of digging through raw output.
✦ Rules authoring & evaluation
Author .rule.json / .rules.json rule files with language support and a visual Rule editor,
evaluate them against your data, and manage rule configuration and providers without leaving the editor.
Rules can check data or add to it (derived values other rules can use), and facts can come
from live lookups against your HTTP APIs, with stored credentials.
✦ LDEx-aware
Built for the LIMRA LDEx standard: BEM/EOIS/BCM/RSP schema settings, validation
presets, local-only data handling (your data stays in your editor; Dot Star does not
collect it), and carrier/employer configuration.
Turn Dot Star's tools on inside your AI assistant over MCP, so you can map, validate,
and transform benefits data by just asking. The AI Tools panel in the Dot Star DX
Studio sidebar shows what your license has turned on and switches it on in one click. In
Cursor and Windsurf, DX Studio writes the editor's own MCP settings for you; for apps that
don't share your editor's settings, like Claude Desktop, "Set up in another app" gives
you the right config. The tools work across your assistant's Ask, Plan, and Agent modes.
The Set Up AI Tools (Optional) walkthrough covers it.
✦ Cross-IDE
One extension for VS Code, Cursor, and Windsurf/Devin. The "Set Up AI Guidance
for Mapping" command drops the right instructions file for whichever editor you're in
(.github/instructions, .cursor/rules, or .windsurf/rules).
Editor support: requires VS Code 1.101+ (and current Cursor / Windsurf, which track that base). The VS Code build uses the latest AI/MCP APIs, feature-detected so the extension still loads on the forks.
For developers
Every mapping is a DataSonnet script (a .ds file) you can read, edit or write by hand.
✦ DataSonnet mapping with live preview
First-class support for .ds transformation scripts: syntax highlighting,
IntelliSense (completions, hover, signature help), and inline diagnostics. Press
Cmd/Ctrl+Enter to run the transform and see the output instantly, with your input
payloads auto-resolved from the workspace.
✦ Step-through debugging + Mapping Variable Inspector
Set breakpoints in a .ds script and F5 to debug it. The Mapping Variable Inspector shows
local values captured on each run, so you can see exactly how a mapping evaluates.
✦ Ask your AI assistant
A @datasonnet chat participant answers ds.*/std.* function questions, reviews
your active script for issues, and looks up LDEx schema structure, in plain conversation.
Example: two CSV rosters to LDEx BEM
Turn two CSV rosters into a schema-valid LDEx BEM transmission (press Cmd/Ctrl+Enter for a live preview):
/** DataSonnet
version=2.0
input payload application/csv
input coverage application/csv
output application/vnd.limra.ldex.bem+json;version=2.0
*/
// Two CSV rosters (demographics + coverage) -> a schema-valid LDEx BEM transmission.
// The carrier and employer envelope come from the LDEx plugin config; this script
// builds the employees. Value maps translate the source codes into LDEx values.
local ldex = import "ldex/bem.libsonnet";
local maps = import "valuemaps/maps.libsonnet";
// Relationship "E" marks the employee; everyone else is a dependent, grouped by SSN.
local employees = std.filter(function(r) r.Relationship == "E", payload);
local depsBySSN = ds.arrays.groupBy(std.filter(function(r) r.Relationship != "E", payload), function(d) d.SSN);
local covsBySSN = ds.arrays.groupBy(coverage, function(c) c.SSN);
local employeeObjects = std.mapWithIndex(function(i, emp)
local eeID = "ee-" + ds.strings.zeroPad(i, 3);
local dependents = std.map(function(dep) {
dependentSocialSecurityNumber: dep.SSN,
dependentRelationshipTypeCode: maps.relationship(dep.Relationship), // S -> Spouse, C -> Child
dependentName: { lastName: dep.LastName, firstName: dep.FirstName },
dependentGenderCode: maps.gender(dep.Gender), // M/F -> Male/Female
}, std.get(depsBySSN, emp.SSN, []));
local coverages = std.map(function(cov) ldex.buildCoverage({
productTypeCode: "CriticalIllness",
coverageTierCode: maps.coverageTier(cov.CoverageLevel), // EE -> Employee, EF -> EmployeeFamily
benefitAmount: std.parseInt(cov.CoverageAmt),
coverageEffectiveDate: cov.EFFECTIVE,
employeePartyID: eeID,
}), std.get(covsBySSN, emp.SSN, []));
ldex.assembleEmployee({
employeePartyID: eeID,
employeeSocialSecurityNumber: emp.SSN,
employeeName: { lastName: emp.LastName, firstName: emp.FirstName },
employeeBirthDate: emp.DOB,
employeeGenderCode: maps.gender(emp.Gender),
employeeMailingAddress: ldex.buildAddress(emp),
coverage: coverages,
}, { dependent: dependents }),
employees);
ldex.buildTransmission({ employee: employeeObjects })
→ a schema-valid LDEx BEM transmission (abbreviated):
{
"transmission": {
"employer": {
"employerName": "Sample Demo Employer",
"employee": [
{
"employeePartyID": "ee-000",
"employeeName": { "lastName": "Doe", "firstName": "Jane" },
"employeeGenderCode": "Female",
"coverage": [
{ "productTypeCode": "CriticalIllness", "coverageTierCode": "EmployeeFamily", "benefitAmount": 20000 }
],
"dependent": [
{ "dependentName": { "lastName": "Doe", "firstName": "John" }, "dependentRelationshipTypeCode": "Spouse" }
]
}
]
}
}
}
Illustrative and trimmed for brevity. The carrier/employer envelope and value maps come from your project's LDEx configuration.
Getting started
- Install Dot Star DX Studio from the Marketplace (or your provided
.vsix).
- Activate your license: run DX Studio: Enter Offline License Token and paste the
token from your Dot Star account. (IAM sign-in is coming.) See the
activation guide.
- Open Home from the DX Studio sidebar and choose Map a File to a New Format, then
Send a File to a Partner to set up its delivery.
On first run, the Get Started with DX Studio walkthrough opens and takes you from
activating your license to your first Test Delivery and Deliver to Production. Turning on
your AI tools has its own walkthrough, Set Up AI Tools (Optional).
.ds syntax highlighting works for everyone; the engine, preview, debugging, and chat
unlock with a datasonnet entitlement.
What's included
| Capability |
Status |
| AI mapping drafts (Map This File, Home wizard) |
✅ Available (in-editor with a chat model such as Copilot; otherwise hands off to your AI chat) |
| Pipeline Builder: visual editor, New Pipeline wizard, Generate-with-AI |
✅ Available |
| Pick Up and Deliver: folder and SFTP connections, Set Up a Delivery, Test Delivery, Deliver to Production |
✅ Available |
| Business-friendly Mapping Report |
✅ Available |
| Fixed-width output + Record Layout Editor |
✅ Available |
| Value Maps & Rule Variables visual editors |
✅ Available |
| Rules authoring: language, visual Rule editor, evaluation, config & providers |
✅ Available |
DataSonnet .ds language + live preview |
✅ Available |
| Step-through debugging + Mapping Variable Inspector |
✅ Available |
| DataSonnet / LDEx chat participant |
✅ Available (VS Code) |
| DataSonnet & Rules tools in your AI chat (MCP) + AI Tools panel & walkthrough |
✅ Available (VS Code, Cursor, Windsurf) |
| LDEx Mapper (hosted MCP) |
✅ Available (connect your LDEx server) |
| DX API views |
🔜 Coming |
| IAM single sign-on |
🔜 Coming |
About Dot Star LLC
Dot Star LLC transforms workforce benefits & group-insurance technology: strategic consulting,
hands-on engineering, and purpose-built accelerators that move carriers, benefit
administrators, and brokers from legacy workflows to modern, AI-powered solutions. Learn
more at benefits.dotstar.ai.
Licensing & Support
Dot Star DX Studio is free to install. Authoring (opening and editing mappings, rules, and pipelines)
is available to everyone; running transforms, evaluating rules, running pipelines, and the AI tools require
a Dot Star license. The extension verifies an offline license token, so no account or network connection
is required to run licensed features.
Features marked "Coming" in the table above are still in progress.
LDEx Standard and LIMRA License
This package implements the LIMRA Data Exchange (LDEx) standard. It contains
Dot Star's own TypeScript types, validation schemas, and runtime logic built
against the published standard. It does not include any LIMRA-authored
specification files (.xsd, sample payloads, OpenAPI documents, or LIMRA
documentation).
You must obtain your own LDEx license from LIMRA. The LDEx Standard is the
intellectual property of LL Global, Inc. ("LIMRA") and is provided under
LIMRA's Grant of License, which does not permit Dot Star to redistribute or
sublicense the Standard. To use this package to exchange LDEx-formatted data:
- Obtain the LDEx Standard directly from LIMRA (https://www.limra.com) under
LIMRA's own terms.
- Where a runtime requires the LIMRA schema files themselves (for example,
XSD-based validation), supply your own LIMRA-downloaded copies via the
package's schema path/configuration option. This package does not ship them.
Dot Star LLC is not affiliated with, sponsored by, or endorsed by LIMRA or
LL Global, Inc. LDEx and LIMRA are trademarks of LL Global, Inc. or its
affiliates and are used here solely to describe compatibility with the published
standard.
See THIRD_PARTY_NOTICES for full third-party
attribution.
Proprietary software, licensed not sold; see LICENSE.md. Building on it?
See CONTRIBUTING.md.