Dataset Declaration and SDT Mapping

Part of the WebMEM® Protocol
Location: /protocol/sdt/dataset/
Status: Current Draft
Last Updated: 2026-08-24

Overview

A Semantic Data Template (SDT) provides the page-level machine knowledge representation of a web resource. To make that representation discoverable using an established web vocabulary, WebMEM may pair the SDT with a Schema.org Dataset declaration expressed as JSON-LD.

The Dataset declaration and the SDT serve different purposes.

Dataset JSON-LD declares that a machine-facing dataset exists and describes that dataset using a widely recognized vocabulary.
The SDT defines the semantic organization of the machine knowledge represented by that dataset.
WebMEM fragments organize the knowledge within the SDT according to semantic purpose.

The relationship is:

Web Resource
│
├── Dataset JSON-LD
│   └── declares and describes the machine-facing dataset
│
└── Semantic Data Template
    ├── Fragment
    ├── Fragment
    └── Fragment

Schema.org declares the dataset. WebMEM defines the knowledge structure the dataset contains.

Why Use Dataset JSON-LD?

WebMEM introduces a machine knowledge representation that is more expressive than conventional page-level metadata. That does not require WebMEM to replace established structured-data vocabularies where those vocabularies already perform a useful function.

Schema.org Dataset provides an established way for a publisher to describe a dataset associated with a web resource.

It can communicate information such as:

dataset identity;
dataset name;
description;
publisher or creator;
canonical resource location;
temporal coverage;
spatial coverage;
modification date;
license;
and distribution information.

WebMEM can use that existing declaration layer while reserving the SDT for the richer semantic representation Schema.org Dataset does not attempt to provide.

Discovery and Representation Are Different Functions

The Dataset declaration provides a discovery and description layer.

The SDT provides a knowledge representation layer.

These functions should remain distinct.

Dataset JSON-LD may tell a machine:

There is a dataset associated with this resource. This is its identity, name, publisher, scope, and distribution.

The SDT tells a machine:

This is how the publisher has organized the machine-facing knowledge represented by that dataset.

The Fragment Classes then establish:

This part represents identity. This part represents source-observed facts. This part represents derived statistics. This part represents an index. This part represents provenance, policy, procedure, explanation, or another defined semantic role.

Dataset declaration therefore complements WebMEM rather than competing with it.

The Dataset Represents the SDT as a Whole

The page-level Dataset declaration should describe the machine knowledge representation represented by the SDT as a whole.

It should not normally declare each individual WebMEM fragment as though each fragment were an unrelated page-level dataset.

Conceptually:

Dataset
└── SDT
    ├── IdentityFragment
    ├── MetaFragment
    ├── IndexFragment
    ├── DataFragment
    └── DerivedStatsFragment

The fragments remain modular knowledge objects within the SDT.

The Dataset declaration identifies the composed machine-facing dataset associated with the resource.

This preserves the SDT as the page-level composition boundary.

Dataset Identity

The Dataset declaration should provide a stable identity for the machine-facing dataset.

Under JSON-LD, this identity is established through @id.

For example:

{
  "@context": "https://schema.org",
  "@type": "Dataset",
  "@id": "https://example.org/resource/#webmem",
  "name": "Example Resource WebMEM Dataset"
}

The identifier should be stable enough to distinguish the WebMEM dataset from other objects associated with the same resource.

The page URL itself may identify the web resource:

https://example.org/resource/

while:

https://example.org/resource/#webmem

identifies the machine-facing dataset associated with that resource.

The exact identifier convention may vary by implementation, but the Dataset identity and the resource identity should not be conflated when they represent different objects.

Binding Dataset Identity to the SDT

The Dataset declaration and the SDT should be explicitly associated with the same machine-facing knowledge representation.

The preferred WebMEM pattern is to use the Dataset @id as the stable identity referenced by the SDT.

For example:

<script type="application/ld+json">
{
  "@context": "https://schema.org",
  "@type": "Dataset",
  "@id": "https://example.org/resource/#webmem",
  "name": "Example Resource WebMEM Dataset",
  "url": "https://example.org/resource/"
}
</script>

<template
  data-webmem-sdt
  data-sdt-id="https://example.org/resource/#webmem">

  ...

</template>

In this example:

https://example.org/resource/ identifies the web resource;
https://example.org/resource/#webmem identifies the Dataset;
and the SDT uses the same dataset identity through data-sdt-id.

The shared identifier creates an explicit binding between the Dataset declaration and the SDT.

The Dataset and SDT should not merely coexist on the same page. They should identify the same machine-facing dataset.

Dataset-to-SDT Mapping

Schema.org Dataset properties describe characteristics of the page-level dataset. WebMEM uses the SDT to represent the knowledge contained within that dataset.

A typical mapping may include:

Dataset Property	Relationship to the SDT
`@id`	Provides the stable identity used to bind the Dataset declaration to the SDT.
`@type`	Declares the page-level object as a Schema.org `Dataset`.
`name`	Provides a human-readable name for the machine-facing dataset.
`description`	Describes the subject and scope of the knowledge represented by the SDT.
`url`	Identifies the web resource associated with the SDT.
`creator`	Identifies the person or organization responsible for creating the published dataset when applicable.
`publisher`	Identifies the organization responsible for publishing the dataset when applicable.
`datePublished`	Identifies the publication date of the page-level dataset when applicable.
`dateModified`	Identifies the date on which the published dataset was materially updated.
`temporalCoverage`	Identifies the time period represented by the SDT when a dataset-level temporal scope applies.
`spatialCoverage`	Identifies the geographic scope represented by the SDT when a dataset-level geographic scope applies.
`license`	Identifies applicable licensing or reuse terms for the published dataset.
`distribution`	Describes an accessible representation or distribution of the dataset.

The mapping should represent actual dataset-level properties. It should not force fragment-level semantics into Dataset properties merely because a superficially similar property exists.

Dataset-Level Scope and Fragment-Level Scope

Dataset JSON-LD describes the SDT at the page level.

Individual fragments may have more specific scopes.

For example:

Dataset
  spatialCoverage: Mohave County, Arizona
  temporalCoverage: 2026

SDT
  ├── IndexFragment
  │   scope: Mohave County, 2026
  │
  ├── DataFragment
  │   entity: plan:H5521-290-0
  │   plan_year: 2026
  │
  └── MetaFragment
      source dataset scope: United States

The Dataset describes the page-level machine knowledge as county-scoped.

The MetaFragment may still describe a national CMS source dataset from which county-level knowledge was selected.

The Dataset declaration should not overwrite or erase these more specific fragment-level distinctions.

Dataset scope describes the composed SDT. Fragment scope describes the knowledge object within that composition.

Creator, Publisher, and Source Are Different Concepts

The creator or publisher of the WebMEM Dataset is not necessarily the creator of every source dataset represented within the SDT.

For example:

WebMEM Dataset
  publisher: Example Publisher

MetaFragment
  source dataset: CMS Medicare Advantage Landscape
  creator: Centers for Medicare & Medicaid Services

The publisher may transform, organize, normalize, compose, or derive knowledge from CMS data without becoming the creator of the underlying CMS dataset.

Likewise, CMS does not become the publisher of the WebMEM dataset merely because CMS data provides its source material.

These distinctions should remain explicit.

Dataset JSON-LD describes the published page-level dataset. WebMEM provenance describes the lineage of the knowledge represented within it.

Dataset Metadata Is Not Provenance

Dataset metadata and WebMEM provenance overlap in some information but serve different purposes.

Dataset metadata may identify:

the dataset name;
publisher;
publication date;
geographic coverage;
temporal coverage;
license;
and distribution.

WebMEM provenance may additionally establish:

which source supports a particular fragment or assertion;
which publisher transformation was applied;
which sources were combined;
how a derived statistic was calculated;
which source version was used;
when source data was retrieved;
and how the evidentiary lineage differs among knowledge objects within the SDT.

A page-level Dataset declaration should therefore not be treated as a substitute for fragment- or assertion-level provenance.

Read the Provenance specification →

Dataset JSON-LD Does Not Define Fragment Semantics

Schema.org Dataset provides a vocabulary for describing datasets.

It does not define the internal semantic roles represented by WebMEM Fragment Classes.

For example, Dataset JSON-LD does not inherently distinguish among:

source-observed factual assertions;
derived statistics;
entity identity;
collection membership;
policy rules;
eligibility logic;
procedural steps;
canonical definitions;
recommendations;
or machine-resolution relationships.

Those distinctions are represented by the SDT and its Fragment Classes.

This separation allows Schema.org to perform the job it already performs well without requiring it to become the internal knowledge model for WebMEM.

Dataset JSON-LD Does Not Replace the SDT

A Dataset declaration may accurately describe a machine-facing dataset while still leaving the contents of that dataset semantically opaque.

For example:

{
  "@context": "https://schema.org",
  "@type": "Dataset",
  "name": "2026 Medicare Options in Example County",
  "spatialCoverage": "Example County",
  "temporalCoverage": "2026"
}

This tells a machine that a dataset exists and describes its broad subject and scope.

It does not tell the machine:

which entities are represented;
which values are source-observed;
which statistics are derived;
which identifiers represent plans, contracts, or segments;
how those entities relate;
which sources support which assertions;
or what must be resolved before a particular value applies.

The SDT provides that internal knowledge representation.

The SDT Does Not Replace Dataset JSON-LD

The inverse is also true.

An SDT may contain a rich machine knowledge representation, but Dataset JSON-LD provides a conventional page-level declaration through which the publisher can identify that representation as a dataset and describe it using an established vocabulary.

WebMEM therefore does not need to recreate every general-purpose dataset metadata property inside its own protocol.

The two layers are complementary:

Dataset JSON-LD
  ↓
Discovery and dataset-level description

Semantic Data Template
  ↓
Machine knowledge representation

WebMEM Fragment Classes
  ↓
Semantic organization

Assertions and Structures
  ↓
Published knowledge

Distribution

A Dataset declaration may use distribution to describe how the dataset is made available.

When the WebMEM SDT is embedded directly in the HTML resource, the distribution may identify that HTML resource as the location through which the machine-facing dataset is published.

A simplified example:

{
  "@type": "Dataset",
  "@id": "https://example.org/resource/#webmem",
  "name": "Example Resource WebMEM Dataset",
  "distribution": {
    "@type": "DataDownload",
    "encodingFormat": "text/html",
    "contentUrl": "https://example.org/resource/"
  }
}

The Dataset declaration describes the distribution.

The WebMEM serialization specification defines how the SDT is represented within that HTML.

If additional distributions are published in the future, they may be described independently without changing the semantic meaning of the SDT.

Example: County-Level Dataset Declaration

The following simplified example declares a county-level Medicare machine dataset:

<script type="application/ld+json">
{
  "@context": "https://schema.org",
  "@type": "Dataset",
  "@id": "https://example.org/medicare-options/arizona/mohave-county/#webmem",
  "name": "2026 Medicare Options in Mohave County, Arizona",
  "description": "Structured machine knowledge describing Medicare coverage options, available plans, and derived market statistics for Mohave County, Arizona.",
  "url": "https://example.org/medicare-options/arizona/mohave-county/",
  "publisher": {
    "@type": "Organization",
    "name": "Example Publisher"
  },
  "dateModified": "2026-08-24",
  "temporalCoverage": "2026",
  "spatialCoverage": {
    "@type": "AdministrativeArea",
    "name": "Mohave County, Arizona"
  },
  "distribution": {
    "@type": "DataDownload",
    "encodingFormat": "text/html",
    "contentUrl": "https://example.org/medicare-options/arizona/mohave-county/"
  }
}
</script>

The corresponding SDT uses the same identity:

<template
  data-webmem-sdt
  data-sdt-id="https://example.org/medicare-options/arizona/mohave-county/#webmem">

  <template
    data-webmem-fragment
    data-fragment-class="IdentityFragment"
    data-fragment-id="identity-mohave-county">

    <section
      data-entity-type="County"
      data-entity-id="04015">

      <span data-role="entity-name">
        Mohave County, Arizona
      </span>

    </section>

  </template>

  <template
    data-webmem-fragment
    data-fragment-class="IndexFragment"
    data-fragment-id="index-mohave-county-plans">

    ...

  </template>

  <template
    data-webmem-fragment
    data-fragment-class="DerivedStatsFragment"
    data-fragment-id="stats-mohave-county">

    ...

  </template>

</template>

The Dataset declaration and SDT share the identity:

https://example.org/medicare-options/arizona/mohave-county/#webmem

The Dataset JSON-LD describes the page-level machine dataset.

The SDT represents the internal machine knowledge associated with that dataset.

The fragments organize that knowledge according to semantic role.

The human-facing page remains the canonical web resource on which both representations are published.

Example: Multiple Source Datasets Within One SDT

A page-level WebMEM Dataset may incorporate knowledge originating from multiple external source datasets.

For example:

WebMEM Dataset
└── SDT
    ├── MetaFragment
    │   └── CMS Landscape
    │
    ├── MetaFragment
    │   └── CMS Monthly Enrollment
    │
    ├── MetaFragment
    │   └── CMS Plan Benefit Package
    │
    ├── DataFragment
    │   └── Landscape assertions
    │
    ├── DataFragment
    │   └── Enrollment assertions
    │
    ├── DataFragment
    │   └── PBP assertions
    │
    └── DerivedStatsFragment
        └── publisher-derived knowledge

The page-level Dataset is not identical to any one of those external source datasets.

It is a publisher-created machine knowledge dataset whose contents may be assembled from, normalized from, derived from, or otherwise grounded in those identified sources.

The distinction is important:

Dataset JSON-LD describes the composed WebMEM dataset published on the page;
MetaFragments may describe the external datasets used as sources;
DataFragments preserve source-observed knowledge from those datasets;
DerivedStatsFragments preserve publisher-derived knowledge;
and provenance preserves the lineage connecting the published knowledge to its sources.

Dataset Declaration and Page Identity

The web resource, Dataset, SDT, fragments, and represented entities are different identifiable objects.

For example:

Web Resource
https://example.org/medicare-options/arizona/mohave-county/

Dataset / SDT
https://example.org/medicare-options/arizona/mohave-county/#webmem

County Entity
county:04015

Plan Entity
plan:H5521-290-0

Fragment
identity-mohave-county

These identities should not be collapsed merely because the objects participate in the same publication.

The web resource identifies the page.

The Dataset identity identifies the page-level machine dataset.

The SDT is bound to that Dataset identity.

Entity identifiers identify the subjects represented by the knowledge.

Fragment identifiers identify modular knowledge objects within the SDT.

This separation is essential for reliable relationships and resolution.

Read the Identity specification →

Dataset Declaration and Human-Facing Content

The Dataset declaration does not imply that the web resource exists only as a dataset.

A WebMEM-enabled resource remains a normal web resource for human readers.

Conceptually:

Web Resource
│
├── Human-Facing Representation
│   ├── prose
│   ├── tables
│   ├── navigation
│   ├── citations
│   └── interactive content
│
├── Dataset JSON-LD
│   └── dataset discovery and description
│
└── SDT
    └── machine knowledge representation

The Dataset declaration and SDT provide additional machine-facing representations of knowledge associated with the same resource.

They do not replace the human-facing document.

Dataset Declaration and Serialization

Dataset JSON-LD and HTML-in-HTML are separate serialization mechanisms serving different purposes on the same resource.

Dataset JSON-LD uses:

<script type="application/ld+json">
...
</script>

to serialize the Schema.org Dataset declaration.

The current WebMEM serialization uses:

<template data-webmem-sdt>
...
</template>

to serialize the SDT and its fragments.

The presence of JSON-LD therefore does not make the SDT itself a JSON-LD structure.

Likewise, the presence of HTML-in-HTML does not replace the Dataset declaration.

They are complementary machine-facing structures with different semantic responsibilities.

Read the HTML-in-HTML Serialization specification →

Dataset Declaration Is Optional to the Conceptual SDT Model

The conceptual definition of an SDT does not depend on Schema.org Dataset.

An SDT remains an SDT because of its semantic structure, Fragment Classes, assertions, relationships, context, and provenance—not because it has been declared using a particular external vocabulary.

Dataset JSON-LD is the current recommended WebMEM mechanism for declaring and describing the page-level machine dataset using an established web vocabulary.

This distinction allows the WebMEM knowledge model to remain independent of any single discovery mechanism.

If additional dataset discovery or declaration mechanisms become useful in the future, they may be mapped to the SDT without redefining the SDT itself.

What Dataset JSON-LD Should Not Do

The Dataset declaration should not be overloaded with responsibilities that belong to the SDT.

Dataset JSON-LD should not be used as a substitute for:

Fragment Class declarations;
fragment-level entity scope;
individual factual assertions;
derived-statistic semantics;
fragment-level provenance;
defined-term relationships;
policy logic;
eligibility logic;
procedural structure;
directory structure;
identity hierarchies;
cross-fragment relationships;
or resolution semantics.

Those are responsibilities of WebMEM.

Likewise, the SDT should not recreate generic dataset metadata already represented clearly by the Dataset declaration merely for the sake of duplication.

Conformance

A WebMEM Dataset declaration conforming to this mapping must:

declare the page-level machine dataset using Schema.org Dataset when Dataset JSON-LD is used;
provide a stable Dataset identity through @id;
associate the Dataset with the web resource on which the SDT is published;
bind the Dataset declaration and SDT to the same machine-dataset identity;
describe dataset-level scope accurately;
distinguish the publisher or creator of the WebMEM dataset from creators of external source datasets when those entities differ;
avoid using Dataset metadata as a substitute for fragment- or assertion-level provenance;
avoid representing fragment-specific scope as though it necessarily applies to the entire Dataset;
avoid using Dataset properties to flatten semantic distinctions represented by WebMEM Fragment Classes;
and maintain consistency between the Dataset declaration and the SDT it identifies.

The absence of Dataset JSON-LD does not invalidate the conceptual structure of an otherwise conforming SDT unless a particular WebMEM conformance profile explicitly requires Dataset declaration.

Relationship to WebMEM 1.x

WebMEM 1.x explored multiple mechanisms for exposing structured machine knowledge, including semantic digests, content-negotiated endpoints, JSON-LD exports, Turtle, Markdown, XML, and other machine-facing representations.

The current protocol simplifies that architecture.

The SDT is the page-level machine knowledge representation.

HTML-in-HTML is the current serialization used to publish that representation within the web resource.

Schema.org Dataset JSON-LD provides an established page-level mechanism for declaring and describing the resulting machine dataset.

This removes the need to make external digest endpoints or multiple export formats foundational to the protocol.

It also clarifies the relationship between WebMEM and Schema.org.

Schema.org provides the dataset declaration. WebMEM provides the internal knowledge architecture.

The two systems are complementary rather than competing structured-data models.

Dataset Declaration and SDT Mapping

Overview

Why Use Dataset JSON-LD?

Discovery and Representation Are Different Functions

The Dataset Represents the SDT as a Whole

Dataset Identity

Binding Dataset Identity to the SDT

Dataset-to-SDT Mapping

Dataset-Level Scope and Fragment-Level Scope

Creator, Publisher, and Source Are Different Concepts

Dataset Metadata Is Not Provenance

Dataset JSON-LD Does Not Define Fragment Semantics

Dataset JSON-LD Does Not Replace the SDT

The SDT Does Not Replace Dataset JSON-LD

Distribution

Example: County-Level Dataset Declaration

Example: Multiple Source Datasets Within One SDT

Dataset Declaration and Page Identity

Dataset Declaration and Human-Facing Content

Dataset Declaration and Serialization

Dataset Declaration Is Optional to the Conceptual SDT Model

What Dataset JSON-LD Should Not Do

Conformance

Relationship to WebMEM 1.x

Related SDT Documents

Related Protocol Documents