Skip to content
| Marketplace
Sign in
Visual Studio Code>Data Science>Dot Star DX StudioNew to Visual Studio Code? Get it now.
Dot Star DX Studio

Dot Star DX Studio

Dot Star

|
24 installs
| (0) | Free
AI-powered tooling for workforce benefits & group insurance. Map, validate, and transform LDEx and any benefits & insurance data, right inside VS Code, Cursor, and Windsurf.
Installation
Launch VS Code Quick Open (Ctrl+P), paste the following command, and press enter.
Copied to clipboard
More Info

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:

  1. 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.
  2. 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.
  3. 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.
  4. Test Delivery. Picks up the matching files without moving them, runs the pipeline and sends the results to your test destination only.
  5. 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.

✦ Your tools in any AI chat (MCP)

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

  1. Install Dot Star DX Studio from the Marketplace (or your provided .vsix).
  2. 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.
  3. 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.

  • License inquiries & support: info@dotstar.io
  • Activate a license: run DX Studio: Enter Offline License Token from the Command Palette, or see docs/licensing/activation.md.

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:

  1. Obtain the LDEx Standard directly from LIMRA (https://www.limra.com) under LIMRA's own terms.
  2. 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.

  • Contact us
  • Jobs
  • Privacy
  • Manage cookies
  • Terms of use
  • Trademarks
  • Your Privacy Choices
  • Consumer Health Privacy
© 2026 Microsoft