@adukiorg/anza 0.2.0

package/CHANGELOG.md

@@ -0,0 +1,137 @@
+# Changelog
+
+All notable changes to `@adukiorg/anza` will be documented here.
+
+Format follows [Keep a Changelog](https://keepachangelog.com/en/1.0.0/).  
+Versioning follows [Semantic Versioning](https://semver.org/).
+
+---
+
+## [Unreleased]
+
+### Planned
+
+- Full element library documentation (`src/elements/`)
+- Integration with external bundlers/compilers
+
+---
+
+## [0.2.0] — 2026-06-07
+
+### Added
+
+#### Compiler — `anza`
+- **Dependency Graph Walking**: Automated dependency resolution of ESM imports/exports.
+- **Tree-Shaking**: Outputs only referenced files to `dist/`, excluding unused code.
+- **Automatic Inline Importmaps**: Optimal `<script type="importmap">` generated and injected inline into HTML entry points.
+- **Relative Component Styles & Templates**: Parses relative template and stylesheet file paths referenced in `ui.element` relative to `import.meta.url`.
+- **Concurrent File Watcher**: Recompiles output on file modifications.
+- **SSE HMR Dev Server**: CSS hot-swapping and HTML/JS auto-reloading via Server-Sent Events (SSE).
+- **Nested /dist Routing**: Added router nested service mapping in Axum dev server for development path parity.
+
+#### Structure
+- **Monorepo Split**: Reorganized files into `/library` (NPM package), `/sample` (demo application), and `/tools` (Rust compiler).
+
+#### Sample
+- **Cyberpunk Blog SPA**: Features reactive store, category filters, instant search, likes count persistence, details page with lightweight custom markdown renderer, post publishing, and post deletion.
+
+---
+
+## [0.1.0] — 2026-05-27
+
+### Added
+
+#### Package
+
+- Published as `@adukiorg/anza` — pure browser ESM, zero build step
+- Scoped subpath exports for every core module (`/api`, `/state`, `/storage`, etc.)
+- `"type": "module"` — fully native ESM, no CommonJS wrapper
+- `npm test` via `@web/test-runner` (real Chromium, no jsdom)
+- `npm run serve` via `@web/dev-server` on port 8080
+
+#### Core — `@adukiorg/anza/api`
+
+- `execute()` — fetch wrapper with AbortSignal, timeout, and `scheduler.postTask` integration
+- `PlatformError` — unified error shape across all network failures
+- `retry()` — exponential backoff with jitter and AbortSignal support
+- `stream()` — async generator streaming over NDJSON responses
+- `createNDJSONTransform()` — reusable `TransformStream` for NDJSON parsing
+- `upload()` — multipart file upload with progress events
+- `pipeline` — composable request/response middleware pipeline
+- Cache strategies: `cache-first`, `network-first`, `stale-while-revalidate`
+
+#### Core — `@adukiorg/anza/state`
+
+- `ReactiveStore` — Proxy-based reactive state with microtask-batched notifications
+- `setActiveSubscriber` / `getActiveSubscriber` — dependency tracking context
+- `derived()` — auto-tracked computed values that re-evaluate on dependency changes
+- `sync()` — BroadcastChannel cross-tab state synchronization
+
+#### Core — `@adukiorg/anza/events`
+
+- `EventBus` — typed pub/sub with wildcard patterns and AbortSignal cleanup
+- `events` — singleton global event bus instance
+
+#### Core — `@adukiorg/anza/router`
+
+- `register()` / `match()` — URL pattern registration and matching
+- `clear()` / `getRoutes()` — route registry management
+- `addGuard()` — async navigation guard hooks
+- `setNotFound()` — 404 handler
+- `setup()` — bootstraps native Navigation API interception
+- Full programmatic history API: `navigate`, `replace`, `back`, `forward`, `go`, `current`, `entries`
+- `renderOutlet()` — declarative route outlet rendering
+
+#### Core — `@adukiorg/anza/storage`
+
+- `Database` — Promise-wrapped IndexedDB with sequential migrations
+- `LRUCache` / `WeakLRUCache` — in-memory LRU caches with optional TTL
+- `storage` — unified tiered facade: memory → IndexedDB → Cache API → OPFS
+- `quota` — storage estimate and persistence request helpers
+
+#### Core — `@adukiorg/anza/offline`
+
+- `queue` — IndexedDB-backed offline operation queue with FIFO dequeue
+- `check()` / `subscribe()` — connectivity detection and change subscriptions
+
+#### Core — `@adukiorg/anza/animations`
+
+- `animate()` — WAAPI wrapper with AbortSignal and easing controls
+- `stagger()` — staggered multi-element animation groups with `finished` promise
+
+#### Core — `@adukiorg/anza/workers`
+
+- `lock()` — Web Locks API facade with timeout and AbortSignal support
+- `WorkerPool` — managed pool of Web Workers with task queue and concurrency limits
+
+#### Core — `@adukiorg/anza/security`
+
+- `sanitize()` — XSS-safe HTML sanitizer using `DOMParser`
+- `uuid()` — `crypto.randomUUID()` wrapper
+- `hash()` — SHA-256/384/512 via Web Crypto API
+- `generateKey()` / `deriveKey()` — AES-GCM key generation and PBKDF2 derivation
+- `encrypt()` / `decrypt()` — AES-GCM symmetric encryption/decryption
+
+#### Core — `@adukiorg/anza/platform`
+
+- `supports` — feature detection registry for 30+ browser APIs
+- `reset()` — cache reset utility (used in tests)
+
+#### Core — `@adukiorg/anza/ui`
+
+- `BaseElement` — Shadow DOM base class for all custom elements
+- Design token cascade: primitive → semantic → component token layers
+
+#### Tests
+
+- 26 test suites, 70 assertions — all running in real Chromium via `@web/test-runner`
+- Browser-native import maps injected per test run — no Node.js module resolution
+
+#### Blog Demo
+
+- `blog/` — sample SPA demonstrating state, storage, offline queue, and animations
+- Import map mirrors the published `@adukiorg/anza/*` subpath exports exactly
+
+[Unreleased]: https://github.com/aduki-org/native/compare/v0.2.0...HEAD
+[0.2.0]: https://github.com/aduki-org/native/compare/v0.1.0...v0.2.0
+[0.1.0]: https://github.com/aduki-org/native/releases/tag/v0.1.0

package/README.md

@@ -0,0 +1,215 @@
+# @adukiorg/anza
+
+> Anza web platform library. Pure browser ESM — no bundler, no framework lock-in. A small local Rust toolchain resolves your import graph into a minimal, browser-native `dist/`.
+
+[![npm](https://img.shields.io/npm/v/@adukiorg/anza)](https://www.npmjs.com/package/@adukiorg/anza)
+[![license](https://img.shields.io/npm/l/@adukiorg/anza)](./LICENSE)
+[![tests](https://img.shields.io/badge/tests-237%20passing-brightgreen)](#testing)
+
+---
+
+## What is this?
+
+`@adukiorg/anza` is a modular, zero-dependency platform library built entirely on top of browser-native APIs:
+
+| Module | What it wraps |
+| --- | --- |
+| `/api` | `fetch`, Streams API, `scheduler.postTask` |
+| `/state` | ES Proxy, `queueMicrotask`, `BroadcastChannel` |
+| `/events` | Custom pub/sub with AbortSignal cleanup |
+| `/router` | Navigation API, History API |
+| `/storage` | IndexedDB, Cache API, OPFS, LRU memory |
+| `/offline` | IDB-backed operation queue, `navigator.onLine` |
+| `/animations` | WAAPI (`element.animate`), stagger groups |
+| `/workers` | Web Locks API, Web Workers pool |
+| `/security` | Web Crypto API, `DOMParser` XSS sanitizer |
+| `/platform` | Feature detection for 30+ browser APIs |
+| `/ui` | Shadow DOM base element, design token cascade |
+| `/elements` | Custom element library |
+
+No virtual DOM. No transpilation. The library is authored as plain `.js` files in `library/src/`. The bundled-in Rust toolchain (`tools/`) walks your ESM `import` graph from your entry points and emits **only the modules you actually use** into `dist/`, preserving a folder structure the browser resolves natively.
+
+---
+
+## Installation
+
+To install `@adukiorg/anza` in your project:
+
+```bash
+npm install @adukiorg/anza
+```
+
+---
+
+## Workspace Structure
+
+The codebase is organized as a monorepo containing:
+
+- **`library/`**: The core package codebase (`src/`, `tests/`, `package.json`, etc.).
+- **`sample/`**: A sample application demonstrating reactive state, routing, and component separation in action.
+- **`tools/`**: The Rust compiler toolchain codebase (`anza`).
+- **`scripts/`**: Toolchain build and release helper scripts.
+
+---
+
+## Building the Toolchain & Running the Sample
+
+The compiler (`anza`) is a native Rust CLI that manages the build pipeline.
+
+### 1. Build the compiler
+From the workspace root directory:
+```bash
+node scripts/build.js
+```
+This builds the release binary into `tools/target/release/anza`.
+
+### 2. Run the Sample Application
+Navigate into the sample project:
+```bash
+cd sample
+npm install     # Links to the local library package
+npm run build   # Performs graph resolution and emits output to dist/
+npm run dev     # Starts dev server on port 8080 with HMR and routing fallbacks
+```
+
+---
+
+## What the Toolchain Does
+
+- **Graph Walking**: Resolves the full import graph starting from your entry points (`src/index.js` by default, plus module scripts found in HTML templates).
+- **Tree-Shaking**: Copies only the reached modules into `dist/`. Unreferenced files and assets are completely excluded.
+- **Automatic Inline Importmap**: Analyzes import references and automatically generates/injects an optimal `<script type="importmap">` tag inline in your HTML files.
+- **Static Asset Copying**: Automatically copies templates (`.html`) and stylesheets (`.css`) referenced by your components.
+- **Strict Validation**: Fails the build on unresolved imports, syntax errors, or invalid component prop declarations.
+- **HMR Dev Server**: Serves your files with a SSE live-reload listener. Modifying a CSS file hot-swaps it in place; HTML/JS modifications trigger a fast page reload.
+
+---
+
+## Splitting a Component Across Files
+
+You can separate a component's logical code, templates, and styles into separate files for clean maintainability. The compiler resolves the relative template and stylesheet paths, processes them, and emits them to `dist/`:
+
+### `ui-button/template.html`
+```html
+<button class="btn" ref="button">
+  <slot></slot>
+</button>
+```
+
+### `ui-button/style.css`
+```css
+:host { display: inline-block; }
+.btn { background: var(--color-primary); color: white; border: none; }
+```
+
+### `ui-button/index.js`
+```js
+import { ui } from '@adukiorg/anza/ui';
+
+ui.element('ui-button', {
+  template: './template.html',
+  style: './style.css',
+  props: {
+    disabled: { type: Boolean, default: false }
+  },
+  mount({ el, refs, on }) {
+    on.click('[ref="button"]', () => {
+      console.log('Button clicked!');
+    });
+  }
+}, import.meta.url);
+```
+
+---
+
+## Quick Examples
+
+### Reactive State
+
+```js
+import { state } from '@adukiorg/anza/state';
+
+const store = state.create({ count: 0, theme: 'dark' });
+
+store.subscribe('count', () => {
+  console.log('count changed to', store.get('count'));
+});
+
+store.set('count', 1);  // fires after microtask flush
+store.set('count', 2);  // batched — only one notification fires
+```
+
+### Network Requests
+
+```js
+import { api, PlatformError } from '@adukiorg/anza/api';
+
+try {
+  const data = await api.get('https://api.example.com/posts');
+  console.log(data);
+} catch (err) {
+  if (err instanceof PlatformError) {
+    console.error(err.code, err.message); // 'NETWORK_TIMEOUT', 'HTTP_ERROR', etc.
+  }
+}
+```
+
+### IndexedDB Storage
+
+```js
+import { Database } from '@adukiorg/anza/storage';
+
+const db = new Database('myapp', 1, [
+  (db) => db.createObjectStore('posts')
+]);
+
+await db.open();
+await db.set('posts', 'post-1', { title: 'Hello', content: '...' });
+const post = await db.get('posts', 'post-1');
+```
+
+### Animations
+
+```js
+import { animate, stagger } from '@adukiorg/anza/animations';
+
+// Single element
+animate(el, [{ opacity: 0 }, { opacity: 1 }], { duration: 300 });
+
+// Staggered group
+const cards = document.querySelectorAll('.card');
+stagger(Array.from(cards), [
+  { transform: 'translateY(20px)', opacity: 0 },
+  { transform: 'translateY(0)',    opacity: 1 }
+], { duration: 250, staggerDelay: 60 });
+```
+
+### Client-Side Router
+
+```js
+import { register, navigate } from '@adukiorg/anza/router';
+
+register('/posts/:id', async ({ params }) => {
+  const post = await fetchPost(params.id);
+  renderPost(post);
+});
+
+navigate('/posts/42');
+```
+
+---
+
+## Testing
+
+Tests run in **real Chromium** via `@web/test-runner` — no jsdom or node mocks.
+
+```bash
+cd library
+npm test
+```
+
+---
+
+## License
+
+[MIT](./LICENSE) © 2026 Aduki

package/bin/anza.js

@@ -0,0 +1,63 @@
+#!/usr/bin/env node
+
+/**
+ * library/bin/anza.js
+ *
+ * Node.js wrapper for the anza Rust binary.
+ * Detects the platform and spawns the correct pre-built binary.
+ *
+ * In development: uses tools/target/release/anza (two levels up).
+ * In npm install: uses pre-built platform binary from bin/.
+ */
+
+import { fileURLToPath } from 'url';
+import { dirname, join } from 'path';
+import { existsSync } from 'fs';
+import { spawn } from 'child_process';
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname  = dirname(__filename);
+
+// library/bin/ → library/ → repo root
+const library = join(__dirname, '..');
+const root    = join(library, '..');
+
+function binary() {
+  // Development: repo binary (built by `node scripts/build.js`)
+  const dev = join(root, 'tools', 'target', 'release', 'anza');
+  if (existsSync(dev)) return dev;
+
+  // npm install: pre-built platform binary alongside this script
+  const platform = process.platform;
+  const arch     = process.arch;
+
+  const map = {
+    darwin: { x64: 'anza-macos-x64',    arm64: 'anza-macos-arm64' },
+    linux:  { x64: 'anza-linux-x64',    arm64: 'anza-linux-arm64' },
+    win32:  { x64: 'anza-windows-x64.exe', arm64: 'anza-windows-arm64.exe' },
+  };
+
+  const name = map[platform]?.[arch];
+  if (!name) {
+    console.error(`Unsupported platform: ${platform} ${arch}`);
+    process.exit(1);
+  }
+
+  const prebuilt = join(__dirname, name);
+  if (existsSync(prebuilt)) return prebuilt;
+
+  console.error(
+    'anza binary not found.\n' +
+    'Run: node scripts/build.js  (from the repo root)'
+  );
+  process.exit(1);
+}
+
+const child = spawn(binary(), process.argv.slice(2), { stdio: 'inherit' });
+
+child.on('error', (err) => {
+  console.error('Failed to spawn anza:', err.message);
+  process.exit(1);
+});
+
+child.on('exit', (code) => process.exit(code ?? 0));

package/bin/create.js

@@ -0,0 +1,150 @@
+#!/usr/bin/env node
+/**
+ * scripts/create.js  (also used as library/bin/create.js → npx anza-create)
+ *
+ * Scaffolds a new anza app project in the given directory.
+ * Usage:
+ *   npx anza-create myapp
+ *   npx anza-create .          (current directory)
+ */
+
+import { mkdirSync, writeFileSync, existsSync } from 'fs';
+import { join, resolve, basename } from 'path';
+
+const arg = process.argv[2];
+
+if (!arg || arg === '--help' || arg === '-h') {
+  console.log('Usage: npx anza-create <name>');
+  console.log('       npx anza-create .     (scaffold in current dir)');
+  process.exit(arg ? 0 : 1);
+}
+
+const target = resolve(arg);
+const name = arg === '.' ? basename(process.cwd()) : basename(target);
+
+if (existsSync(target) && arg !== '.') {
+  console.error(`Error: '${target}' already exists.`);
+  process.exit(1);
+}
+
+console.log(`Scaffolding anza app: ${name}\n`);
+
+// Directory structure
+const dirs = [
+  '',
+  'src',
+  'src/elements',
+  'src/styles',
+  'src/tokens',
+];
+
+for (const dir of dirs) {
+  mkdirSync(join(target, dir), { recursive: true });
+}
+
+// src/index.html
+writeFileSync(join(target, 'src', 'index.html'), `<!DOCTYPE html>
+<html lang="en">
+  <head>
+    <meta charset="utf-8" />
+    <meta name="viewport" content="width=device-width, initial-scale=1" />
+    <title>${name}</title>
+
+    <!-- Tokens & global styles -->
+    <link rel="stylesheet" href="/dist/tokens/index.css" />
+    <link rel="stylesheet" href="/dist/styles/global.css" />
+
+    <!-- App entry -->
+    <script type="module" src="/dist/index.js"></script>
+  </head>
+  <body>
+    <!-- App root -->
+  </body>
+</html>
+`);
+
+// src/index.js
+writeFileSync(join(target, 'src', 'index.js'), `/**
+ * src/index.js — app entry point
+ */
+import '@adukiorg/anza/ui';
+
+// Import your elements
+// import './elements/dashboard/index.js';
+`);
+
+// src/styles/global.css
+writeFileSync(join(target, 'src', 'styles', 'global.css'), `/* global.css — global app styles */
+
+*,
+*::before,
+*::after {
+  box-sizing: border-box;
+  margin: 0;
+  padding: 0;
+}
+
+body {
+  font-family: system-ui, sans-serif;
+  line-height: 1.5;
+}
+`);
+
+// src/tokens/index.css
+writeFileSync(join(target, 'src', 'tokens', 'index.css'), `/* tokens/index.css — design tokens */
+
+:root {
+  /* Colors */
+  --color-primary: #6366f1;
+  --color-surface: #ffffff;
+  --color-text: #111827;
+
+  /* Spacing */
+  --space-1: 0.25rem;
+  --space-2: 0.5rem;
+  --space-4: 1rem;
+  --space-8: 2rem;
+
+  /* Radius */
+  --radius-sm: 0.25rem;
+  --radius-md: 0.5rem;
+  --radius-lg: 1rem;
+
+  /* Shadow */
+  --shadow-sm: 0 1px 2px rgb(0 0 0 / 0.05);
+  --shadow-md: 0 4px 6px rgb(0 0 0 / 0.07);
+}
+`);
+
+// package.json
+writeFileSync(join(target, 'package.json'), JSON.stringify({
+  name,
+  version: '0.1.0',
+  private: true,
+  type: 'module',
+  scripts: {
+    dev: 'anza dev',
+    build: 'anza build',
+  },
+  devDependencies: {
+    '@adukiorg/anza': 'latest',
+  }
+}, null, 2));
+
+// .gitignore
+writeFileSync(join(target, '.gitignore'), `node_modules/
+dist/
+.anza-build-cache.json
+`);
+
+console.log('Created:');
+for (const dir of dirs.filter(Boolean)) {
+  console.log(`  ${name}/${dir}/`);
+}
+console.log(`  ${name}/src/index.html`);
+console.log(`  ${name}/src/index.js`);
+console.log(`  ${name}/package.json`);
+console.log(`\nNext steps:`);
+console.log(`  cd ${arg === '.' ? '.' : name}`);
+console.log(`  npm install`);
+console.log(`  npm run dev`);

package/importmap.json

@@ -0,0 +1,72 @@
+{
+  "imports": {
+    "@adukiorg/anza":           "/dist/index.js",
+
+    "@adukiorg/anza/api":        "/dist/core/api/index.js",
+    "@adukiorg/anza/state":      "/dist/core/state/index.js",
+    "@adukiorg/anza/events":     "/dist/core/events/index.js",
+    "@adukiorg/anza/router":     "/dist/core/router/index.js",
+    "@adukiorg/anza/storage":    "/dist/core/storage/index.js",
+    "@adukiorg/anza/offline":    "/dist/core/offline/index.js",
+    "@adukiorg/anza/animations": "/dist/core/animations/index.js",
+    "@adukiorg/anza/workers":    "/dist/core/workers/index.js",
+    "@adukiorg/anza/security":   "/dist/core/security/index.js",
+    "@adukiorg/anza/platform":   "/dist/core/platform/index.js",
+    "@adukiorg/anza/ui":         "/dist/core/ui/index.js",
+
+    "@adukiorg/anza/elements":             "/dist/elements/index.js",
+
+    "@adukiorg/anza/elements/button":      "/dist/elements/primitives/button/index.js",
+    "@adukiorg/anza/elements/icon":        "/dist/elements/primitives/icon/index.js",
+    "@adukiorg/anza/elements/badge":       "/dist/elements/primitives/badge/index.js",
+    "@adukiorg/anza/elements/avatar":      "/dist/elements/primitives/avatar/index.js",
+    "@adukiorg/anza/elements/divider":     "/dist/elements/primitives/divider/index.js",
+    "@adukiorg/anza/elements/text":        "/dist/elements/primitives/text/index.js",
+    "@adukiorg/anza/elements/link":        "/dist/elements/primitives/link/index.js",
+    "@adukiorg/anza/elements/spinner":     "/dist/elements/primitives/spinner/index.js",
+
+    "@adukiorg/anza/elements/input":       "/dist/elements/forms/input/index.js",
+    "@adukiorg/anza/elements/textarea":    "/dist/elements/forms/textarea/index.js",
+    "@adukiorg/anza/elements/select":      "/dist/elements/forms/select/index.js",
+    "@adukiorg/anza/elements/checkbox":    "/dist/elements/forms/checkbox/index.js",
+    "@adukiorg/anza/elements/radio":       "/dist/elements/forms/radio/index.js",
+    "@adukiorg/anza/elements/toggle":      "/dist/elements/forms/toggle/index.js",
+    "@adukiorg/anza/elements/field":       "/dist/elements/forms/field/index.js",
+    "@adukiorg/anza/elements/upload":      "/dist/elements/forms/upload/index.js",
+    "@adukiorg/anza/elements/form":        "/dist/elements/forms/form/index.js",
+
+    "@adukiorg/anza/elements/dialog":      "/dist/elements/overlay/dialog/index.js",
+    "@adukiorg/anza/elements/popover":     "/dist/elements/overlay/popover/index.js",
+    "@adukiorg/anza/elements/tooltip":     "/dist/elements/overlay/tooltip/index.js",
+    "@adukiorg/anza/elements/menu":        "/dist/elements/overlay/menu/index.js",
+    "@adukiorg/anza/elements/drawer":      "/dist/elements/overlay/drawer/index.js",
+    "@adukiorg/anza/elements/sheet":       "/dist/elements/overlay/sheet/index.js",
+
+    "@adukiorg/anza/elements/alert":       "/dist/elements/feedback/alert/index.js",
+    "@adukiorg/anza/elements/toast":       "/dist/elements/feedback/toast/index.js",
+    "@adukiorg/anza/elements/progress":    "/dist/elements/feedback/progress/index.js",
+    "@adukiorg/anza/elements/skeleton":    "/dist/elements/feedback/skeleton/index.js",
+    "@adukiorg/anza/elements/empty":       "/dist/elements/feedback/empty/index.js",
+
+    "@adukiorg/anza/elements/table":       "/dist/elements/data/table/index.js",
+    "@adukiorg/anza/elements/list":        "/dist/elements/data/list/index.js",
+    "@adukiorg/anza/elements/card":        "/dist/elements/data/card/index.js",
+    "@adukiorg/anza/elements/chart":       "/dist/elements/data/chart/index.js",
+    "@adukiorg/anza/elements/stat":        "/dist/elements/data/stat/index.js",
+
+    "@adukiorg/anza/elements/nav":         "/dist/elements/navigation/nav/index.js",
+    "@adukiorg/anza/elements/tabs":        "/dist/elements/navigation/tabs/index.js",
+    "@adukiorg/anza/elements/breadcrumb":  "/dist/elements/navigation/breadcrumb/index.js",
+    "@adukiorg/anza/elements/pagination":  "/dist/elements/navigation/pagination/index.js",
+    "@adukiorg/anza/elements/steps":       "/dist/elements/navigation/steps/index.js",
+
+    "@adukiorg/anza/elements/app":         "/dist/elements/layout/app/index.js",
+    "@adukiorg/anza/elements/header":      "/dist/elements/layout/header/index.js",
+    "@adukiorg/anza/elements/sidebar":     "/dist/elements/layout/sidebar/index.js",
+    "@adukiorg/anza/elements/stack":       "/dist/elements/layout/stack/index.js",
+    "@adukiorg/anza/elements/grid":        "/dist/elements/layout/grid/index.js",
+    "@adukiorg/anza/elements/split":       "/dist/elements/layout/split/index.js",
+    "@adukiorg/anza/elements/scroll":      "/dist/elements/layout/scroll/index.js",
+    "@adukiorg/anza/elements/surface":     "/dist/elements/layout/surface/index.js"
+  }
+}