@reqvire-org/ads 0.3.18 → 0.3.21

package/docs/BEHAVIORS.md

@@ -25,6 +25,14 @@ These gates inspect supported direct imports, markup and style boundaries.
 External package internals and delegated DOM behavior still require source,
 build and browser review; declaring a dependency does not prove it is headless.
 
+New owner registrations can live in `<Owner>.ads.contract.ts` with actual API and
+implementation references; legacy JSON remains supported. The
+[contract reference](CONTRACTS.md) covers static authoring, `.ads.behavior.spec.ts`,
+declarative `exercises`, required browser checks and guarded migration.
+A contract declaration alone is not passing evidence. Use
+`auditBehaviorPaints(frame)` after relevant binding updates to repeat the current
+App's generic paint audit, in addition to assertions for the named guarantee.
+
 ## Development boundary
 
 Production includes real components, controllers, tokens and compiled styles.
@@ -366,3 +374,10 @@ Keep ESM modules and explicit imports. Avoid an eagerly imported controller
 registry. Tree shaking and shared chunks follow the project bundler: class methods,
 side effects, global CSS and dynamic maps can retain extra code. Inspect emitted
 resources instead of assuming a controller produces a minimal bundle.
+
+Development-only `review/<Owner>` units may register the same guarantee/check
+contracts for review presentation and controls. Subjects can name that owner's
+separate review API or local headless helpers; checks still run registered project
+profiles and can refer to an existing real scenario. This grants no production
+API, catalogue entry, `covers` credit or runtime import permission. See the
+[portable review guide](../skills/ads-designer/references/review.md).

package/docs/CHANGELOG.md

@@ -1,5 +1,47 @@
 # Changelog
 
+## Unreleased
+
+## 0.3.21
+
+- Add statically read TypeScript owner contracts and canonical `.ads.` development
+  roles, retaining legacy token/behavior registration and stable scenario IDs.
+- Validate constrained paint inputs, source-proven instance binding producers and
+  declarative child consumers. Audit current paint bindings/local SVG resources
+  inside Apps; registered browser checks remain required for guarantees.
+- Close supported cross-owner TypeScript token-value flows and preserve independent
+  render evidence with positioned scenario field/entry diagnostics.
+- Prepare contract/file-role migrations as normal guarded owner drafts; expose
+  compact contract/API metadata and portable guidance in all five skills.
+- Expose read-only token-origin analysis for explicit project scale policies.
+- Keep starter production declarations limited to the public runtime dependency
+  closure, excluding development contracts, scenarios, review and checks.
+- Reuse contract TypeScript programs during discovery. Match failed Playwright
+  steps to the unhandled case error so nested API event order and earlier caught
+  failures cannot mislabel an assertion as a runner failure.
+
+
+## 0.3.20
+
+- Preserve the motion-review checklist separately from the development review-layer
+  guide; both remain self-contained in the motion skill. Version 0.3.19 was tagged
+  but publication was cancelled before this correction.
+
+- Separate project-owned review UI from production patterns. Add `review/` owners,
+  a configurable development entry and derived `/review` alias, guarded companion
+  exports and review contracts. Preserve real component/token render evidence,
+  block production imports and verify review assets stay out of product bundles.
+  Move the working showcase and empty starter helpers to the new layer; publish
+  self-contained migration guidance in all skills and `ads://guides/review`.
+- Enable native form validation and submit events across the showcase, diagnostic
+  explorer and legacy App iframe layers. Retain opaque App origins and block
+  native action requests through CSP. Cover click/Enter submission, custom/native
+  validation and no-network behavior in generic React, Preact and HTML Apps.
+- Enforce runtime component dependency direction and public component contracts
+  for patterns through aliases, re-exports and helpers. Reject proven private
+  style-hook/variable access while preserving ancestor-context layout and documented
+  customization. Publish portable layer guidance in every skill and through MCP.
+
 ## 0.3.18
 
 - Preserve complete typed `@property` registrations through atomic css/styled

package/docs/CONTRACTS.md

@@ -0,0 +1,250 @@
+# Static owner contracts and development files
+
+Use one optional `<Owner>.ads.contract.ts` for owner-local tokens, constrained
+paint inputs, scoped runtime bindings, declarative parts and behavioral checks.
+The import `import type { UnitContract } from "@reqvire-org/ads/contracts"` supplies
+development typing. ADS reads its AST and resolves real symbols without importing
+or executing project modules. It adds no production runtime.
+
+## Files and ownership
+
+```text
+components/Plot/
+  Plot.tsx                     production API/root
+  Series.tsx                   production declarative API
+  renderer.tsx                 production consumer
+  paints.ts                    production binding producer
+  types.ts                     production prop types
+  tokens.css                   optional production token definitions
+  Plot.ads.contract.ts         static tool declaration
+  Plot.ads.scenario.tsx         demonstration
+  Plot.ads.fixture.ts           demonstration data
+  Tokens.ads.scenario.tsx       real owner-token samples
+  Tokens.ads.fixture.ts         sample bindings/probes
+  Plot.ads.behavior.spec.ts     registered browser checks
+  Plot.ads.test.tsx             optional unit tests
+  Plot.ads.helpers.ts           development-only adapters
+  README.md                    API/provenance
+```
+
+This is an example, not a required inventory. Use the same roles for patterns,
+controllers and relevant development owners. `review/` remains a separate
+shared development layer; its implementation filenames need no extra marker.
+Runtime components, types and styles cannot import `.ads.` files, tests, fixtures
+or review code through aliases, barrels or helpers. Unknown `.ads.` roles are
+still development-only and are diagnosed. Fixtures/helpers cannot define styles;
+put demo framing in review. Ordinary README/license files retain their names.
+
+Scenarios/fixtures/review enter only the selected preview closure. Contracts are
+never executable preview modules; derived audit descriptors are data. Specs run
+only in the configured test runner. Production declaration emission must also
+start from the public runtime entry, rather than include every file under the
+design-system folder. The starter’s `tsconfig.build.json` does this; its normal
+no-emit typecheck still checks development sources. Core import guards protect
+the runtime dependency closure. Review custom emitter configurations through
+the configuration owner before migrating a consuming project. Guards remain tooling. Production prop types
+belong in runtime files, never inferred from a development contract.
+
+## A contract uses actual implementation references
+
+```ts
+import type { UnitContract } from "@reqvire-org/ads/contracts";
+import { Plot } from "./Plot";
+import { Series } from "./Series";
+import { Renderer } from "./renderer";
+import { paints } from "./paints";
+
+export default {
+  schemaVersion: 1,
+  tokens: { namespace: "--plot-", stylesheet: "./tokens.css" },
+  paintInputs: [
+    { api: Plot, property: "config.*.paint", kind: "paint-reference" },
+    { api: Series, property: "fill", kind: "paint-reference", bindings: ["items"] },
+  ],
+  bindings: {
+    items: {
+      input: { api: Plot, property: "config" },
+      producer: paints,
+      valueFrom: "paint",
+      variable: "--plot-runtime-${key}",
+      scope: { api: Plot, selector: '[data-plot-root=""]' },
+      checks: ["isolation"],
+    },
+  },
+  declarativeParts: [
+    { api: Series, parent: Plot, consumer: Renderer, checks: ["isolation"] },
+  ],
+  behavior: {
+    subjects: { plot: { api: Plot }, renderer: { implementation: Renderer } },
+    guarantees: [{
+      id: "scoped-output",
+      description: "Changing either instance updates only its own output.",
+      subjects: ["plot", "renderer"], checks: ["isolation"],
+    }],
+    checks: {
+      isolation: {
+        file: "./Plot.ads.behavior.spec.ts", case: "isolation",
+        scenario: "components/Plot", profile: "widget",
+      },
+    },
+  },
+} satisfies UnitContract;
+```
+
+Keep contracts small; most owners need none or one section. Supported data are
+literal objects/arrays, static constants/spreads, `as const` and `satisfies`.
+Symbol references resolve through normal imports, aliases and re-exports.
+Calls, getters, methods, computed metadata and environment-dependent expressions
+are rejected. Function references are opaque identities, never executed.
+Private implementation subjects may be internal module exports without becoming
+public barrel exports. Producers/consumers must belong to the same owner. Required
+checks must exist, back named guarantees and use a browser profile with the
+corresponding scenario. A relationship is registration, not a passing guarantee.
+
+## Typed paints and runtime bindings
+
+Production-facing types can use:
+
+```ts
+export type Paint = `var(--${string})` | `url(#${string})` | "none" | "currentColor";
+export interface SeriesProps { fill?: Paint }
+export type Config = Readonly<Record<string, { paint: Paint }>>;
+```
+
+ADS follows the actual property path/type, including nested maps. A name such as
+`Paint`, an arbitrary `string`, `any` or a forged metadata role grants no waiver.
+Supported references are a single accessible token/binding `var(--name)`, a local
+SVG paint `url(#id)`, `none` or `currentColor`. Fallbacks, raw colours, external
+URLs and arbitrary CSS are outside this role. Raw domain colours need a separately
+reviewed validated input boundary; they are not implicitly supported here.
+
+A runtime family is instance data, not an infinite design-token inventory. Its
+source proof requires the declared config map, exact key/value mapping and actual
+root attachment. Supported producers use `Object.entries(config)` with a loop,
+or `Object.fromEntries(...map(...))`; same-owner helper returns are traceable.
+Guard each key before the write/return using
+`if (!/^[A-Za-z0-9_-]+$/.test(key)) throw new Error("Invalid key")` (a loop may
+`continue`). Return only the computed map. For example:
+
+```ts
+export function paints(config: Config) {
+  const result: Record<string, string> = {};
+  for (const [key, entry] of Object.entries(config)) {
+    if (!/^[A-Za-z0-9_-]+$/.test(key)) throw new Error("Invalid key");
+    result[`--plot-runtime-${key}`] = entry.paint;
+  }
+  return result;
+}
+```
+
+The runtime root attaches that returned map using `style={paints(config)}` or a
+traceable local/useMemo result and the declared class/exact data attribute.
+Place spreading props before the explicit scope/style so an unknown spread
+cannot replace them. This grants permission to that binding attachment only;
+it does not authorize arbitrary inline styling, CSSProperties APIs or bulk writes.
+Unsupported dynamic producers/attachment paths fail with an analysis diagnostic.
+Keep the implementation project-owned; there is no required ADS binding helper.
+
+Families cannot overlap shared tokens, owner-token namespaces, private runtime
+prefixes or other bindings. A broad family such as `--color-${key}` grants no
+shared-token exception. Use a distinct private family where collision freedom
+cannot be established. Registered paint consumers list their allowed binding IDs;
+borrowing a peer's family or private token remains invalid. Bindings are scoped
+to their actual root; portals outside it need deliberate project integration.
+
+The App audit checks current mounted instances, accessible values, local SVG
+resources and computed paint-property responses. Visibility and complete rendered
+output still need assertions in the registered browser checks. It rejects missing/duplicate IDs and reports unobserved written values separately. It is bounded to 100 families, 20 instances per family, 100 keys
+and 1000 elements per instance. Exceeding a budget reports limits and complete: false; it does not invalidate a
+working component. An unobserved paint effect also remains unverified until its
+relevant consumer/state is checked. It does
+not prove every future input, visibility state or interaction. In registered
+Playwright checks, use `auditBehaviorPaints(frame)` from
+`@reqvire-org/ads/verification` after updates. Assert `result.ok` and, when claiming complete current-map
+evidence, `result.complete` and the expected `verified` entries.
+Exercise two instances with identical keys/different paints, key updates/removal,
+themes, local SVG IDs and invalid/inaccessible references. Keep normal runner
+profiles; React StrictMode still needs a project development harness.
+
+## Rendered and declarative evidence
+
+`covers` names rendered public UI. A null-returning declarative part belongs in
+`exercises`, alongside behavioral APIs:
+
+```tsx
+export const scenario = {
+  title: "Plot", covers: ["Plot"], exercises: ["Series"],
+};
+```
+
+The real part must reach its registered consumer through a rendered parent.
+ADS resolves source identity comparisons (`child.type === Series`, including a
+traceable comparison helper) and reads of that same child’s props traced from the consumer’s children input.
+A comparison against a decoy object gives no evidence. An import, unrelated parent, unused
+child or metadata claim gives no consumption credit. Unknown render branches are
+conservative. Browser checks must verify that adding/removing/changing the part
+changes output. Source relationships and current browser evidence are separate.
+Do not add fake DOM, hide public parts or rewrite a valid API to appease tracing.
+
+Scenario metadata is validated by field/entry with positions and reasons.
+A bad entry still blocks acceptance while valid independent render evidence is
+retained. Unreadable prerequisites report coverage as not established. Inspect
+the exact source diagnostic and bounded results; do not assume every subsequent
+missing preview means its runtime API is invalid.
+
+## Local tokens and project consistency
+
+`tokens.css` remains optional production design data for component/pattern owners,
+imported by the runtime owner. Controllers stay headless; review uses the shared
+vocabulary and its own development presentation state. Only root/theme definitions belong there. Tokens require real sample
+coverage, including independently built owner token scenarios. One namespace
+cannot be shared by peer components. Private references remain private through
+TS constants, re-exports, helper returns, SVG/paint props and property reads/writes.
+Normal composition of a public component using its own tokens remains valid.
+Source analysis covers supported value flows; arbitrary dynamic code is not
+proof of ownership. CSS variables remain browser-visible; namespacing is an
+architecture boundary, not browser encapsulation.
+
+Ownership does not establish a project's visual scale:
+
+- A component redefining shared `--space-4` fails.
+- Its private `--plot-gap: 7px` can be valid component geometry.
+- `--plot-gap: var(--space-4)` preserves a shared scale with local meaning.
+
+Choose project policy explicitly. A registered project check can use tooling-only
+`inspectTokens(root)` and `inspectTokenOrigins(inventory, name, { stopAt: names })`
+from `@reqvire-org/ads`. `aliasOnly` verifies every theme definition follows only
+aliases to the explicitly selected origins; `literals` and `diagnostics` explain
+violations/limits. Select the exact targets and permitted shared origins. Keep
+intentional geometry exceptions exact with documented reasons. ADS neither
+infers spacing meaning from names nor prescribes a global spacing palette.
+
+## Migration and MCP editing
+
+Legacy `tokens.json`/`<Owner>.tokens.json` and `behavior.json` remain readable.
+Use either authoring form per section; competing declarations fail. New contracts
+normalize into the same discovery, ownership, source revisions, affected-check
+selection and candidate gates. `ads_units` exposes `contractFile`; `ads_catalog`
+reports constrained paint paths and declarative parent/consumer/check references.
+Use bounded file reads and paged detailed results, not repeated whole-project dumps.
+
+Install supporting ADS tooling before migrating a consuming project and reconnect
+MCP before replacing a package used by a running server. Then:
+
+1. Discover one owner with `ads_units`.
+2. `ads_prepare_patch({ unit, action: "migrate" })` creates a normal local draft.
+3. Review the converted contract, renamed files/imports and migration notes.
+4. `ads_prepare_patch({ unit, action: "diff", draft })` emits its Git patchFile.
+5. Dry-run/apply with `ads_apply_patch`, or a genuinely coupled transaction.
+
+Migration never edits live source or bypasses gates. It retains stable scenario
+IDs and check case IDs. An optional static `scenario.id` preserves a legacy
+identity when a renamed filename would otherwise be ambiguous; it must stay
+inside the owning unit and be unique. Whole-file or unimportable private behavior subjects stay
+in legacy registration with a note until deliberately resolved. Unknown runner
+globs, custom adapters and documentation references require review. Ambiguous
+flat-to-directory renames stay in the legacy form with a migration note so file
+ownership cannot silently change. Preserve
+licenses, pending drafts and unrelated work; keep transactions within their limits.
+There is no alternate JSON contract editor. Do not loosen a guard or make a valid
+API private merely to complete a migration.

package/docs/GUIDE.md

@@ -494,11 +494,11 @@ export default function Scenario() { return <Button>{fixture.label}</Button>; }
 
 IDs derive from filenames; do not maintain another registry or hand-assigned IDs.
 Token scenarios live beside foundation CSS under the configured token directory.
-The starter includes `tokens/Foundation.scenario.tsx` and its local fixture for
-a project-owned token review pattern. Keep its presentation in that pattern:
+The starter includes `tokens/Foundation.ads.scenario.tsx` and its local fixture for
+a project-owned token review renderer. Keep its presentation in that pattern:
 
 ```tsx
-import { TokenSamples } from "@ds";
+import { TokenSamples } from "@ds/review";
 import { fixture } from "./Typography.fixture";
 export const scenario = { title: fixture.title, covers: ["TokenSamples"], samples: fixture.samples };
 export default function Scenario() { return <TokenSamples {...fixture} />; }
@@ -723,6 +723,7 @@ inspection errors fail the check. These guards read files and never delete them.
   "dsDir": "design-system",
   "publicAlias": "@ds",
   "publicEntry": "index.ts",
+  "reviewEntry": "review/index.ts",
   "stylesEntry": "styles.css",
   "tokenDir": "tokens",
   "inlineStyleFiles": [],
@@ -807,3 +808,28 @@ creates the GitHub release. Stable tags publish as `latest`; prerelease tags
 publish as `next`. Check the workflow result and npm version before updating
 consumer dependencies. The manual workflow moves a label to an existing
 published version; it does not publish new source.
+
+## Owner contracts and migration
+
+New colocated development source uses `<Name>.ads.<role>.ts[x]`: contract,
+scenario, fixture, helpers, test, spec or behavior.spec. Optional
+`<Owner>.ads.contract.ts` consolidates token/behavior declarations with typed
+paint and declarative-consumer contracts. Production APIs/types stay in runtime
+files. ADS reads contract data statically; no project import runs during discovery.
+See [CONTRACTS.md](CONTRACTS.md) for exact fields, supported producer forms and
+source/browser limits. Older JSON and unmarked recognized development filenames
+remain supported during migration.
+
+With supporting tooling installed and MCP reconnected, discover one owner, call
+`ads_prepare_patch` with `action: "migrate"`, inspect the local draft/notes, and use
+normal diff, dry-run and apply gates. This never changes live source by itself.
+Review custom runner globs and unimportable private subjects before application;
+migrate passing owners in stages and preserve pending agent drafts.
+
+Project scale policies remain explicit. A registered check can call
+`inspectTokenOrigins(inspectTokens(root), target, {stopAt: allowedSharedTokens})`
+from the tooling package. Check `aliasOnly` for strict alias-only policies across
+all themes; inspect `literals`/`diagnostics` for raw values, cycles and limits.
+Choose exact targets/origins and documented geometry exceptions in project code;
+register the command in `mcp.mutationChecks` and the normal build. ADS owns no
+universal spacing scale and infers no design meaning from token names.

package/docs/MCP.md

@@ -1,5 +1,11 @@
 # ADS over MCP
 
+For component/pattern classification and dependency/style boundary diagnostics,
+read `ads://guides/layers`. A component supplies one cohesive UI capability; a
+pattern arranges capabilities into reusable structures/workflows. Guards enforce
+resolved ownership boundaries, not component counts. Scenarios may compose public
+UI to demonstrate their subject; application adapters own store access and routing.
+
 `ads mcp [directory]` serves a project's local design system over stdio. It uses
 the same `ds.config.json`, token inspection and core checks as the CLI. It reads
 source and build artifacts. Optionally it manages one configured project
@@ -54,15 +60,21 @@ managed project compiler on demand and after relevant source changes.
 Switching entries overlays a centered loading spinner, then reveals the new
 scenario inside the existing App. Loading and diagnostic overlays do not move the
 preview. Token presentation comes from project-owned scenarios, fixtures and
-public review patterns, using the project's real foundation CSS and extracted
+development-only review helpers, using the project's real foundation CSS and extracted
 styles. The App runtime contains no token sample templates or named token ordering.
 The generic definition inspector remains available without a scenario build.
 
 There are no required browser-page files in the project. Colocated scenarios and
-fixtures, optional public review-layout patterns, and the project's compiler
+fixtures, optional development-only review helpers, and the project's compiler
 entry supply the presentation. Use the existing runtime URL when MCP is connected
 instead of starting a second compiler for that project.
 
+Development review UI lives in `review/`, behind a separate development entry;
+production patterns remain application UI. Discover `ads_status.project.review`
+and read `ads://guides/review` for imports, guarded owners and migration. Review
+exports are not product catalogue entries. They can frame real scenarios and
+render token samples without entering the deployed application's graph.
+
 ## Connect Codex or Claude
 
 Use the published package through `npx`. No ADS checkout or global installation
@@ -397,6 +409,7 @@ The same discovery covers the rest of the project ADS:
 
 | Unit | Scope |
 |------|-------|
+| `review/<Owner>` | Development-only frames, token renderers, demo controls, local checks and review-entry re-exports |
 | `foundation` | Shared ADS entry styles and root helpers |
 | `documentation` | ADS/project guides, shared credits and license notices, and `licenses/` text collections |
 | `assets/brand`, `assets/fonts`, other `assets/*` groups | Original SVG, image, font and other asset files |
@@ -509,8 +522,8 @@ Install changed dependencies before verification; candidates use the project's
 installed `node_modules`.
 
 Resolve ownership diagnostics by preserving the required capability in its proper
-layer. Demo-only sizing, borders and framing belong in a public review/layout
-pattern; a component API addition needs a runtime use case. Measured imperative
+layer. Demo-only sizing, borders and framing belong in a development-only review
+helper; a component API addition needs a runtime use case. Measured imperative
 geometry uses exact `styleWrites` properties. After migrating JSX inline geometry,
 replace its own boundary entries in the same owner patch and check the final state.
 After the gates pass, verify the behavior in a browser.
@@ -518,7 +531,7 @@ After the gates pass, verify the behavior in a browser.
 A small change needs only its hunk. A complete new component may include its
 implementation, public re-export, scenario and fixture in the same unit patch,
 so coverage is checked against a complete candidate. New units use a new
-`components/`, `patterns/` or `composition/` owner ID following the same colocation
+`components/`, `patterns/`, `controllers/`, `review/` or `composition/` owner ID following the same colocation
 convention. A patch cannot include a peer unit, capture existing peers beneath
 a new directory owner, or change unrelated public-entry statements. Shared
 public-entry changes are limited to re-exports from the selected unit. Alongside
@@ -652,6 +665,14 @@ origin hosts the sandbox proxy; that proxy creates an opaque inner App iframe
 and forwards the standard Apps bridge messages. The diagnostic explorer follows
 the same sandbox model. Only the App materializes and executes project resources.
 
+Both ADS hosts allow native form validation and submission events through all
+iframe layers. Client-side forms use their intended `submit` handlers and
+`preventDefault()`. CSP `form-action 'none'` blocks native action requests;
+`allow-forms` grants neither host DOM access nor top-level navigation. External
+hosts choose their own permissions. See the portable
+[scenario guide](../skills/ads-designer/references/scenarios.md#forms-inside-apps)
+for verification and diagnosis.
+
 For inline documents without an explicit App base URL, ADS supplies
 `<base href="about:srcdoc">` and permits the local `about:` base scheme in CSP.
 Bare and named fragment links retain native in-document navigation and state.
@@ -1023,7 +1044,7 @@ instruction reads alone do not establish Apps/Skills activation.
 ### Token sample verification
 
 Token scenarios declare `samples: fixture.samples` and render a project-owned public
-review pattern with that `samples` input. Each fixture record has `{ token, property,
+review renderer with that `samples` input. Each fixture record has `{ token, property,
 probe }`; the tool discovers the resulting token names. Plain token lists and empty
 covers do not satisfy review coverage. The same bindings travel in the compiled
 resource manifest or self-contained App seed.
@@ -1048,3 +1069,18 @@ Existing projects migrate their token fixtures from name lists to explicit sampl
 records, pass those records into their public renderer, and add the sample markers.
 Rebuild previews with the updated compiler so the contract is included in resources.
 Tool updates do not overwrite existing project-owned scenarios or renderers.
+
+### Static owner contract discovery
+
+`ads_units` includes `contractFile` for a single `<Owner>.ads.contract.ts`.
+`ads_catalog` identifies declarative APIs and their parent/consumer/check links,
+and registered constrained paint-input paths. Read the relevant source range;
+these summaries establish registration, not completed verification. Detailed
+results remain bounded and paged.
+
+`ads_prepare_patch` accepts `action: "migrate"` to prepare marked development
+filenames and compatible legacy sections in a local draft. Inspect its notes,
+then use the existing diff and guarded dry-run/apply workflow. It does not write
+live source, loosen policy or add a second contract-editing protocol. See
+[CONTRACTS.md](CONTRACTS.md) for the static schema, compatibility and browser audits.
+The same guide is available at `ads://guides/contracts`.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@reqvire-org/ads",
-  "version": "0.3.18",
+  "version": "0.3.21",
   "type": "module",
   "description": "A design system your agent can see and shape. Your components. Your look. Your code.",
   "repository": {
@@ -104,6 +104,9 @@
   },
   "exports": {
     ".": "./dist/index.mjs",
+    "./contracts": {
+      "types": "./dist/contracts.d.mts"
+    },
     "./oxlint": "./dist/oxlint.mjs",
     "./linaria": "./dist/linaria.mjs",
     "./tokens": "./dist/contracts/tokens.json",

package/dist/bootstrap-ds/design-system/patterns/token-preview/Scenario.tsx

@@ -1,4 +0,0 @@
-import { TokenPreview } from "@ds";
-import { fixture } from "./fixture";
-export const scenario = { title: fixture.title, covers: ["TokenPreview"] };
-export default function Scenario() { return <TokenPreview {...fixture} />; }

package/dist/bootstrap-ds/design-system/patterns/token-preview/fixture.ts

@@ -1,8 +0,0 @@
-export const fixture = {
-  "title": "Token preview",
-  "text": "Aa",
-  samples: [
-    {"token": "--accent", "property": "background-color", "probe": "rgb(31, 97, 163)"},
-    {"token": "--space-4", "property": "width", "probe": "13.375px"},
-  ]
-} as const;

package/dist/skills/ads-designer/assets/bootstrap-ds/design-system/patterns/token-preview/Scenario.tsx

@@ -1,4 +0,0 @@
-import { TokenPreview } from "@ds";
-import { fixture } from "./fixture";
-export const scenario = { title: fixture.title, covers: ["TokenPreview"] };
-export default function Scenario() { return <TokenPreview {...fixture} />; }

package/dist/skills/ads-designer/assets/bootstrap-ds/design-system/patterns/token-preview/fixture.ts

@@ -1,8 +0,0 @@
-export const fixture = {
-  "title": "Token preview",
-  "text": "Aa",
-  samples: [
-    {"token": "--accent", "property": "background-color", "probe": "rgb(31, 97, 163)"},
-    {"token": "--space-4", "property": "width", "probe": "13.375px"},
-  ]
-} as const;