@nesso-how/theme 0.1.0-alpha.33

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Omar Desogus
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,60 @@
+# @nesso-how/theme
+
+The design tokens for Nesso. This is the one place colours, fonts, spacing and radii are defined. The app, the graph package and the docs site all read from here, so changing a value once changes it everywhere.
+
+Tokens are plain TypeScript objects. Each consumer turns them into CSS variables (or reads the raw hex, for embeds). There is no `theme.css` to import, because the consumers don't share a variable namespace: the app reads `--paper`, Starlight reads `--sl-color-bg`, and so on. Each one emits the variables it needs from the same source.
+
+## What lives here, and what doesn't
+
+Category colours (the `--cat-*` variables for edge types) belong to the relation vocabulary, so they stay in `@nesso-how/relation-types`, not here. A theme pack only names the palette it pairs with (`categoryPalette`); the palette switch and the theme switch stay independent.
+
+A token belongs in this package when it both varies by theme or mode and is shared across the app, the graph and the docs. That covers surface and ink colours, accent, shadows, fonts, and the type, spacing and radii scales. It leaves out anything structural rather than visual: z-index, breakpoints and app layout sizes (status bar height, sidebar width) live in the app, and motion is a foundation constant unless a pack needs to tune it.
+
+## How a theme pack is shaped
+
+A `ThemePack` has two halves.
+
+The mode-varying half is `light` and `dark`: surface colours, accent, the recall heatmap and shadows. You write `dark` as a diff over `light`, listing only what changes. Anything you leave out (the recall scale, in the default pack) is inherited from light, so the two modes never double the work.
+
+The mode-invariant half is identical in light and dark: the fonts, the type scale (sizes, weights, line heights), spacing and radii.
+
+One thing to know about radii: `sm` through `xl` are steps on a scale, but `pill` (999px) and `circle` (50%) are shapes, not steps. Don't reach for them as the small or large end of the ramp.
+
+## Turning tokens into CSS
+
+```ts
+import { defaultTheme, themeCss, modeVars, baseVars } from '@nesso-how/theme'
+
+// A full stylesheet: light tokens under :root, dark under [data-theme='dark'].
+themeCss(defaultTheme)
+
+// Or the flat records, to set on an element yourself.
+baseVars(defaultTheme) // { '--font-sans': "...", '--space-6': '12px', ... }
+modeVars(defaultTheme, 'dark') // { '--paper': '#1a1714', '--accent': '#c47a82', ... }
+```
+
+The app injects `themeCss(defaultTheme)` into the page head at build time, through the `nessoTheme()` Vite plugin in `vite.config.ts`, so the variables exist before the first paint. Category colours are applied separately, from the relation-types palette. The docs site does the same through `docs/scripts/gen-theme-css.mjs`, which also produces a Starlight version with `starlightCss`.
+
+## Changing the default theme
+
+Edit `src/default.ts`. Every colour, font, spacing and radius value the app uses is in there. Change it here, not in the app's CSS or components, and it flows everywhere.
+
+## Adding a theme pack
+
+Start from the default, override only what differs, then register it:
+
+```ts
+// src/packs/ledger.ts
+import { defaultTheme, defineTheme } from '@nesso-how/theme'
+
+export const ledger = defineTheme(defaultTheme, {
+  id: 'ledger',
+  name: 'Ledger',
+  categoryPalette: 'muted',
+  radii: { sm: '2px', md: '3px', lg: '4px' }, // a sharper look
+  light: { color: { paper: '#f7f3e8' } }, // parchment
+  dark: { color: { paper: '#14120d' } }, // its own dark, not a global invert
+})
+```
+
+Then add it to the `themes` map in `src/registry.ts`. `defineTheme` deep-merges and never touches the base, so a pack states only what it changes.

package/dist/css.d.ts

@@ -0,0 +1,15 @@
+import type { ModeTokens, ThemeMode, ThemePack } from './types.js';
+/** Fully resolved colour + shadow tokens for a mode (dark = light + dark diff). */
+export declare function resolveMode(pack: ThemePack, mode: ThemeMode): ModeTokens;
+/** Mode-varying CSS variables (`--paper`, `--ink-2`, `--accent`, `--shadow-md` …). */
+export declare function modeVars(pack: ThemePack, mode: ThemeMode): Record<string, string>;
+/** Mode-invariant CSS variables (fonts, type scale, spacing, radii). */
+export declare function baseVars(pack: ThemePack): Record<string, string>;
+export declare function declarations(vars: Record<string, string>, indent?: string): string;
+/**
+ * Full stylesheet for a pack: mode-invariant tokens + light tokens under
+ * `:root`, dark tokens under `[data-theme='dark']`. Category colours are NOT
+ * emitted here — they come from `@nesso-how/relation-types` `PALETTES`, applied
+ * separately so the palette switch stays orthogonal.
+ */
+export declare function themeCss(pack: ThemePack): string;

package/dist/css.js

@@ -0,0 +1,92 @@
+// SPDX-License-Identifier: MIT
+import { deepMerge } from './merge.js';
+/** Fully resolved colour + shadow tokens for a mode (dark = light + dark diff). */
+export function resolveMode(pack, mode) {
+    return mode === 'light' ? pack.light : deepMerge(pack.light, pack.dark);
+}
+/** Mode-varying CSS variables (`--paper`, `--ink-2`, `--accent`, `--shadow-md` …). */
+export function modeVars(pack, mode) {
+    const { color: c, shadow: s } = resolveMode(pack, mode);
+    return {
+        '--paper': c.paper,
+        '--paper-deep': c.paperDeep,
+        '--ink': c.ink[1],
+        '--ink-2': c.ink[2],
+        '--ink-3': c.ink[3],
+        '--ink-4': c.ink[4],
+        '--ink-5': c.ink[5],
+        '--bg-elev': c.bgElev,
+        '--bg-card': c.bgCard,
+        '--line': c.line,
+        '--line-strong': c.lineStrong,
+        '--grid-dot': c.gridDot,
+        '--accent': c.accent,
+        '--highlight': c.highlight,
+        '--highlight-soft': c.highlightSoft,
+        '--highlight-selection': c.highlightSelection,
+        '--conf-1': c.recall[1],
+        '--conf-2': c.recall[2],
+        '--conf-3': c.recall[3],
+        '--conf-4': c.recall[4],
+        '--conf-5': c.recall[5],
+        '--shadow-md': s.md,
+        '--shadow-lg': s.lg,
+        '--drop-shadow-lg': s.dropLg,
+    };
+}
+/** Mode-invariant CSS variables (fonts, type scale, spacing, radii). */
+export function baseVars(pack) {
+    const { font, type, space, radii } = pack;
+    return {
+        '--font-display': font.display,
+        '--font-sans': font.sans,
+        '--font-mono': font.mono,
+        '--font-feature': font.featureSettings,
+        '--text-xs': type.size.xs,
+        '--text-sm': type.size.sm,
+        '--text-base': type.size.base,
+        '--text-md': type.size.md,
+        '--text-lg': type.size.lg,
+        '--text-xl': type.size.xl,
+        '--font-weight-regular': String(type.weight.regular),
+        '--font-weight-medium': String(type.weight.medium),
+        '--font-weight-semibold': String(type.weight.semibold),
+        '--leading-tight': String(type.leading.tight),
+        '--leading-normal': String(type.leading.normal),
+        '--space-0': space[0],
+        '--space-1': space[1],
+        '--space-2': space[2],
+        '--space-3': space[3],
+        '--space-4': space[4],
+        '--space-5': space[5],
+        '--space-6': space[6],
+        '--space-7': space[7],
+        '--space-8': space[8],
+        '--space-9': space[9],
+        '--radius-none': radii.none,
+        '--radius-sm': radii.sm,
+        '--radius-md': radii.md,
+        '--radius-lg': radii.lg,
+        '--radius-xl': radii.xl,
+        '--radius-pill': radii.pill,
+        '--radius-circle': radii.circle,
+    };
+}
+export function declarations(vars, indent = '  ') {
+    return Object.entries(vars)
+        .map(([name, value]) => `${indent}${name}: ${value};`)
+        .join('\n');
+}
+/**
+ * Full stylesheet for a pack: mode-invariant tokens + light tokens under
+ * `:root`, dark tokens under `[data-theme='dark']`. Category colours are NOT
+ * emitted here — they come from `@nesso-how/relation-types` `PALETTES`, applied
+ * separately so the palette switch stays orthogonal.
+ */
+export function themeCss(pack) {
+    const root = { ...baseVars(pack), ...modeVars(pack, 'light') };
+    return [
+        `:root {\n${declarations(root)}\n}`,
+        `[data-theme='dark'] {\n${declarations(modeVars(pack, 'dark'))}\n}`,
+    ].join('\n\n');
+}

package/dist/default.d.ts

@@ -0,0 +1,12 @@
+import type { ThemePack } from './types.js';
+/**
+ * The default Nesso theme — Notion surface + Oxblood accent. This is the base
+ * pack every other pack derives from via `defineTheme`. Values mirror the tokens
+ * that previously lived as raw CSS in the app's `index.css`; this file is now
+ * their single source of truth.
+ *
+ * `dark` is a *diff* over `light`: it omits `recall`, which is shared across
+ * modes, and the mode-invariant axes (`font`, `type`, `space`, `radii`) are not
+ * repeated per mode at all.
+ */
+export declare const defaultTheme: ThemePack;

package/dist/default.js

@@ -0,0 +1,97 @@
+/**
+ * The default Nesso theme — Notion surface + Oxblood accent. This is the base
+ * pack every other pack derives from via `defineTheme`. Values mirror the tokens
+ * that previously lived as raw CSS in the app's `index.css`; this file is now
+ * their single source of truth.
+ *
+ * `dark` is a *diff* over `light`: it omits `recall`, which is shared across
+ * modes, and the mode-invariant axes (`font`, `type`, `space`, `radii`) are not
+ * repeated per mode at all.
+ */
+export const defaultTheme = {
+    id: 'default',
+    name: 'Notion · Oxblood',
+    categoryPalette: 'default',
+    font: {
+        display: "'Fraunces', Georgia, serif",
+        sans: "'Inter', ui-sans-serif, system-ui, sans-serif",
+        mono: "'JetBrains Mono', ui-monospace, monospace",
+        featureSettings: "'ss01', 'cv11'",
+    },
+    type: {
+        size: {
+            xs: '10.5px',
+            sm: '11px',
+            base: '12px',
+            md: '13px',
+            lg: '15px',
+            xl: '18px',
+        },
+        weight: { regular: 400, medium: 500, semibold: 600 },
+        leading: { tight: 1.2, normal: 1.5 },
+    },
+    space: {
+        0: '0',
+        1: '2px',
+        2: '4px',
+        3: '6px',
+        4: '8px',
+        5: '10px',
+        6: '12px',
+        7: '16px',
+        8: '20px',
+        9: '24px',
+    },
+    radii: {
+        none: '0',
+        sm: '6px',
+        md: '8px',
+        lg: '14px',
+        xl: '20px',
+        pill: '999px',
+        circle: '50%',
+    },
+    light: {
+        color: {
+            paper: '#ffffff',
+            paperDeep: '#f3f1ed',
+            ink: { 1: '#1a1814', 2: '#3c3830', 3: '#6a6356', 4: '#9a9080', 5: '#c4b9a4' },
+            bgElev: '#fbfaf8',
+            bgCard: '#ffffff',
+            line: 'rgba(26, 24, 20, 0.1)',
+            lineStrong: 'rgba(26, 24, 20, 0.2)',
+            gridDot: 'rgba(26, 24, 20, 0.18)',
+            accent: '#6e2730',
+            highlight: '#6e2730',
+            highlightSoft: 'rgba(110, 39, 48, 0.08)',
+            highlightSelection: 'rgba(110, 39, 48, 0.22)',
+            recall: { 1: '#b14a4a', 2: '#c47a3a', 3: '#b89a3a', 4: '#75752d', 5: '#467d2c' },
+        },
+        shadow: {
+            md: '0 8px 28px -10px rgba(26, 24, 20, 0.18), 0 2px 8px rgba(26, 24, 20, 0.06)',
+            lg: '0 28px 60px -16px rgba(26, 24, 20, 0.22), 0 8px 20px -8px rgba(26, 24, 20, 0.1)',
+            dropLg: 'drop-shadow(0 28px 60px rgba(26, 24, 20, 0.22)) drop-shadow(0 8px 20px rgba(26, 24, 20, 0.1))',
+        },
+    },
+    dark: {
+        color: {
+            paper: '#1a1714',
+            paperDeep: '#221e19',
+            ink: { 1: '#f0e9d8', 2: '#d4ccba', 3: '#a39c8c', 4: '#6e6859', 5: '#423e35' },
+            bgElev: '#211d18',
+            bgCard: '#262019',
+            line: 'rgba(240, 233, 216, 0.1)',
+            lineStrong: 'rgba(240, 233, 216, 0.2)',
+            gridDot: 'rgba(240, 233, 216, 0.15)',
+            accent: '#c47a82',
+            highlight: '#c47a82',
+            highlightSoft: 'rgba(196, 122, 130, 0.12)',
+            highlightSelection: 'rgba(196, 122, 130, 0.28)',
+        },
+        shadow: {
+            md: '0 8px 28px -10px rgba(0, 0, 0, 0.55), 0 2px 8px rgba(0, 0, 0, 0.4)',
+            lg: '0 28px 60px -16px rgba(0, 0, 0, 0.7), 0 8px 20px -8px rgba(0, 0, 0, 0.5)',
+            dropLg: 'drop-shadow(0 28px 60px rgba(0, 0, 0, 0.7)) drop-shadow(0 8px 20px rgba(0, 0, 0, 0.5))',
+        },
+    },
+};

package/dist/index.d.ts

@@ -0,0 +1,6 @@
+export type { ColorTokens, ShadowTokens, ModeTokens, FontTokens, TypeScale, TypeStep, SpaceScale, SpaceStep, RadiiScale, ThemePack, ThemeOverride, ThemeMode, DeepPartial, } from './types.js';
+export { defaultTheme } from './default.js';
+export { defineTheme, themes, getTheme } from './registry.js';
+export { resolveMode, modeVars, baseVars, themeCss, declarations } from './css.js';
+export { starlightCss } from './starlight.js';
+export { deepMerge } from './merge.js';

package/dist/index.js

@@ -0,0 +1,5 @@
+export { defaultTheme } from './default.js';
+export { defineTheme, themes, getTheme } from './registry.js';
+export { resolveMode, modeVars, baseVars, themeCss, declarations } from './css.js';
+export { starlightCss } from './starlight.js';
+export { deepMerge } from './merge.js';

package/dist/merge.d.ts

@@ -0,0 +1,4 @@
+import type { DeepPartial } from './types.js';
+export declare function isPlainObject(value: unknown): value is Record<string, unknown>;
+/** Recursively merge `override` onto `base`; `undefined` values are skipped. */
+export declare function deepMerge<T>(base: T, override: DeepPartial<T>): T;

package/dist/merge.js

@@ -0,0 +1,20 @@
+export function isPlainObject(value) {
+    return typeof value === 'object' && value !== null && !Array.isArray(value);
+}
+/** Recursively merge `override` onto `base`; `undefined` values are skipped. */
+export function deepMerge(base, override) {
+    if (!isPlainObject(base) || !isPlainObject(override)) {
+        return override ?? base;
+    }
+    const out = { ...base };
+    for (const [key, value] of Object.entries(override)) {
+        if (value === undefined)
+            continue;
+        const prev = out[key];
+        out[key] =
+            isPlainObject(prev) && isPlainObject(value)
+                ? deepMerge(prev, value)
+                : value;
+    }
+    return out;
+}

package/dist/registry.d.ts

@@ -0,0 +1,10 @@
+import type { ThemeOverride, ThemePack } from './types.js';
+/**
+ * Derive a new theme pack from a base by overriding only what changes. This is
+ * how the registry stays extensible: a new pack declares its diff, not a full
+ * copy. The default pack is the conventional base.
+ */
+export declare function defineTheme(base: ThemePack, override: ThemeOverride): ThemePack;
+/** All built-in packs, keyed by `id`. Add new packs here once defined. */
+export declare const themes: Record<string, ThemePack>;
+export declare function getTheme(id: string): ThemePack;

package/dist/registry.js

@@ -0,0 +1,18 @@
+// SPDX-License-Identifier: MIT
+import { defaultTheme } from './default.js';
+import { deepMerge } from './merge.js';
+/**
+ * Derive a new theme pack from a base by overriding only what changes. This is
+ * how the registry stays extensible: a new pack declares its diff, not a full
+ * copy. The default pack is the conventional base.
+ */
+export function defineTheme(base, override) {
+    return deepMerge(base, override);
+}
+/** All built-in packs, keyed by `id`. Add new packs here once defined. */
+export const themes = {
+    [defaultTheme.id]: defaultTheme,
+};
+export function getTheme(id) {
+    return themes[id] ?? defaultTheme;
+}

package/dist/starlight.d.ts

@@ -0,0 +1,7 @@
+import type { ThemePack } from './types.js';
+/**
+ * Full Starlight stylesheet for a pack. Starlight's default theme is dark
+ * (`:root`); light lives under `:root[data-theme='light']`. `--font-display` is
+ * mode-invariant, so it is emitted once under `:root`.
+ */
+export declare function starlightCss(pack: ThemePack): string;

package/dist/starlight.js

@@ -0,0 +1,44 @@
+// SPDX-License-Identifier: MIT
+import { declarations, resolveMode } from './css.js';
+/**
+ * Map the theme tokens that the Starlight docs/landing site shares with the app
+ * onto Starlight's `--sl-color-*` namespace. Only the cleanly-shared tokens are
+ * emitted (surface, ink scale, accent, hairline); docs-specific chrome that does
+ * not derive from a theme token (admonition colours, the deeper-than-surface
+ * code background, the lighter/darker accent variants, the near-black `gray-7`)
+ * stays owned by `docs/src/styles/custom.css`.
+ */
+function starlightVars(pack, mode) {
+    const { color: c } = resolveMode(pack, mode);
+    return {
+        '--sl-color-bg': c.paper,
+        '--sl-color-bg-nav': c.paper,
+        '--sl-color-bg-sidebar': c.paper,
+        '--sl-color-text': c.ink[1],
+        '--sl-color-text-accent': c.accent,
+        '--sl-color-white': c.ink[1],
+        '--sl-color-black': c.paper,
+        '--sl-color-accent': c.accent,
+        '--sl-color-hairline': c.line,
+        '--sl-color-gray-1': c.ink[1],
+        '--sl-color-gray-2': c.ink[2],
+        '--sl-color-gray-3': c.ink[3],
+        '--sl-color-gray-4': c.ink[4],
+        '--sl-color-gray-5': c.ink[5],
+        '--sl-color-gray-6': c.paperDeep,
+        // App-named tokens consumed directly by docs structural CSS:
+        '--highlight-selection': c.highlightSelection,
+    };
+}
+/**
+ * Full Starlight stylesheet for a pack. Starlight's default theme is dark
+ * (`:root`); light lives under `:root[data-theme='light']`. `--font-display` is
+ * mode-invariant, so it is emitted once under `:root`.
+ */
+export function starlightCss(pack) {
+    const dark = { ...starlightVars(pack, 'dark'), '--font-display': pack.font.display };
+    return [
+        `:root {\n${declarations(dark)}\n}`,
+        `:root[data-theme='light'] {\n${declarations(starlightVars(pack, 'light'))}\n}`,
+    ].join('\n\n');
+}

package/dist/types.d.ts

@@ -0,0 +1,109 @@
+import type { CategoryPalette } from '@nesso-how/relation-types';
+/**
+ * Tokens that change between light and dark mode. A theme pack ships a full
+ * `light` set and a `dark` *diff* (see {@link ThemePack.dark}). Category colours
+ * are intentionally absent: they belong to the relation-type vocabulary
+ * (`@nesso-how/relation-types` `PALETTES`) and are referenced by name via
+ * {@link ThemePack.categoryPalette}, never duplicated here.
+ */
+export interface ColorTokens {
+    paper: string;
+    paperDeep: string;
+    /** 1 = strongest ink, 5 = faintest. Emitted as `--ink`, `--ink-2` … `--ink-5`. */
+    ink: {
+        1: string;
+        2: string;
+        3: string;
+        4: string;
+        5: string;
+    };
+    bgElev: string;
+    bgCard: string;
+    line: string;
+    lineStrong: string;
+    gridDot: string;
+    accent: string;
+    highlight: string;
+    highlightSoft: string;
+    highlightSelection: string;
+    /** FSRS recall heatmap / model-status dots, cool→warm. Emitted as `--conf-1` … `--conf-5`. */
+    recall: {
+        1: string;
+        2: string;
+        3: string;
+        4: string;
+        5: string;
+    };
+}
+export interface ShadowTokens {
+    md: string;
+    lg: string;
+    dropLg: string;
+}
+/** The mode-varying half of a theme: colour + elevation. */
+export interface ModeTokens {
+    color: ColorTokens;
+    shadow: ShadowTokens;
+}
+export interface FontTokens {
+    display: string;
+    sans: string;
+    mono: string;
+    featureSettings: string;
+}
+export type TypeStep = 'xs' | 'sm' | 'base' | 'md' | 'lg' | 'xl';
+export interface TypeScale {
+    size: Record<TypeStep, string>;
+    weight: {
+        regular: number;
+        medium: number;
+        semibold: number;
+    };
+    leading: {
+        tight: number;
+        normal: number;
+    };
+}
+export type SpaceStep = 0 | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9;
+/** Spacing ramp. Step `0` is `0`; subsequent steps grow on the audited rhythm. */
+export type SpaceScale = Record<SpaceStep, string>;
+/**
+ * Border radii. `sm`…`xl` are ramp steps; `pill` and `circle` are *shape
+ * primitives* ("half the height" and `50%`), not rungs of the numeric scale.
+ */
+export interface RadiiScale {
+    none: string;
+    sm: string;
+    md: string;
+    lg: string;
+    xl: string;
+    pill: string;
+    circle: string;
+}
+/**
+ * A complete, selectable visual identity. Mode-invariant axes (`font`, `type`,
+ * `space`, `radii`) sit at the top level; only `light`/`dark` vary by mode, so
+ * the matrix never doubles typography or spacing.
+ */
+export interface ThemePack {
+    id: string;
+    name: string;
+    /** Default category palette this pack pairs with; the palette switch stays orthogonal. */
+    categoryPalette: CategoryPalette;
+    font: FontTokens;
+    type: TypeScale;
+    space: SpaceScale;
+    radii: RadiiScale;
+    light: ModeTokens;
+    /** Diff applied over `light` to produce dark mode; specify only what changes. */
+    dark: DeepPartial<ModeTokens>;
+}
+export type DeepPartial<T> = {
+    [K in keyof T]?: T[K] extends object ? DeepPartial<T[K]> : T[K];
+};
+/** Partial override accepted by `defineTheme` when deriving a pack from a base. */
+export type ThemeOverride = DeepPartial<Omit<ThemePack, 'id' | 'name'>> & {
+    id: string;
+    name: string;
+};
+export type ThemeMode = 'light' | 'dark';

package/dist/types.js

@@ -0,0 +1 @@
+export {};

package/package.json

@@ -0,0 +1,34 @@
+{
+  "name": "@nesso-how/theme",
+  "version": "0.1.0-alpha.33",
+  "description": "Nesso design tokens — the single source of truth for theme packs (colour, typography, spacing, radii) shared across app, graph and docs",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/nesso-how/nesso",
+    "directory": "packages/theme"
+  },
+  "type": "module",
+  "publishConfig": {
+    "access": "public"
+  },
+  "files": [
+    "dist"
+  ],
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js"
+    }
+  },
+  "dependencies": {
+    "@nesso-how/relation-types": "0.1.0-alpha.33"
+  },
+  "devDependencies": {
+    "typescript": "~5.8.3"
+  },
+  "scripts": {
+    "build": "rm -rf dist && tsc",
+    "dev": "tsc --watch"
+  }
+}