sh3-core 0.16.1 → 0.17.2

package/dist/overlays/DrawerSurface.svelte

@@ -0,0 +1,141 @@
+<script lang="ts">
+  /*
+   * One drawer frame anchored to an edge. Renders nothing when closed.
+   * Open state slides the panel in over a backdrop. Tapping the backdrop
+   * fires onClose; tapping the close button does the same.
+   *
+   * Multi-slot drawers render a tab strip in the header. Single-slot
+   * drawers show the slot label only.
+   *
+   * Slot rendering goes through the standard SlotContainer path so the
+   * pooled host (and the mounted view) survives mount/unmount via the
+   * slot host pool — same mechanism as tab-drag re-parents.
+   */
+  import type { DrawerAnchor, DrawerSpec } from '../layout/compact/types';
+  import type { SlotNode } from '../layout/types';
+  import SlotContainer from '../layout/SlotContainer.svelte';
+
+  let {
+    anchor,
+    spec,
+    open,
+    activeSlotId,
+    onClose,
+    onActivate,
+  }: {
+    anchor: DrawerAnchor;
+    spec: DrawerSpec;
+    open: boolean;
+    activeSlotId: string | null;
+    onClose: () => void;
+    onActivate: (slotId: string) => void;
+  } = $props();
+
+  const activeSlot = $derived(
+    spec.slots.find((s) => s.slotId === activeSlotId) ?? spec.slots[0],
+  );
+
+  const slotNode: SlotNode = $derived({
+    type: 'slot',
+    slotId: activeSlot.slotId,
+    viewId: activeSlot.viewId,
+    role: activeSlot.role,
+  });
+</script>
+
+{#if open}
+  <div
+    class="drawer-backdrop"
+    onclick={onClose}
+    onkeydown={(e) => { if (e.key === 'Escape') onClose(); }}
+    role="presentation"
+  ></div>
+  <div
+    class="drawer drawer-{anchor}"
+    data-sh3-region="drawer"
+    data-sh3-anchor={anchor}
+  >
+    <header>
+      <span class="title">{activeSlot.label}</span>
+      <button
+        class="close"
+        onclick={onClose}
+        aria-label="Close drawer"
+      >×</button>
+    </header>
+    {#if spec.slots.length > 1}
+      <div class="tab-strip" role="tablist">
+        {#each spec.slots as s (s.slotId)}
+          <button
+            role="tab"
+            aria-selected={s.slotId === activeSlot.slotId}
+            class:active={s.slotId === activeSlot.slotId}
+            onclick={() => onActivate(s.slotId)}
+          >
+            {s.label}
+          </button>
+        {/each}
+      </div>
+    {/if}
+    <div class="body">
+      <SlotContainer node={slotNode} label={activeSlot.label} />
+    </div>
+  </div>
+{/if}
+
+<style>
+  .drawer-backdrop {
+    position: absolute;
+    inset: 0;
+    background: var(--sh3-overlay-backdrop, rgba(0, 0, 0, 0.35));
+    pointer-events: auto;
+  }
+  .drawer {
+    position: absolute;
+    background: var(--sh3-bg);
+    color: var(--sh3-fg);
+    box-shadow: var(--sh3-shadow-md, 0 0 16px rgba(0, 0, 0, 0.2));
+    display: flex;
+    flex-direction: column;
+    border: 1px solid var(--sh3-border);
+    pointer-events: auto;
+  }
+  .drawer-left  { top: 0; bottom: 0; left: 0;  width: min(360px, 80vw); }
+  .drawer-right { top: 0; bottom: 0; right: 0; width: min(360px, 80vw); }
+  .drawer-top   { left: 0; right: 0; top: 0;   height: min(50vh, 360px); }
+  header {
+    display: flex;
+    align-items: center;
+    padding: var(--sh3-pad-sm) var(--sh3-pad-md);
+    gap: var(--sh3-pad-md);
+    border-bottom: 1px solid var(--sh3-border);
+    background: var(--sh3-bg-elevated);
+  }
+  .title { font-weight: 600; }
+  .close {
+    margin-left: auto;
+    background: none;
+    border: none;
+    font-size: var(--sh3-font-lg);
+    cursor: pointer;
+    color: var(--sh3-fg-muted);
+    padding: 0 var(--sh3-pad-sm);
+  }
+  .close:hover { color: var(--sh3-fg); }
+  .tab-strip {
+    display: flex;
+    gap: 2px;
+    padding: var(--sh3-pad-xs) var(--sh3-pad-sm) 0;
+    background: var(--sh3-bg-sunken);
+  }
+  .tab-strip button {
+    padding: var(--sh3-pad-xs) var(--sh3-pad-sm);
+    border: 1px solid var(--sh3-border);
+    background: var(--sh3-bg-elevated);
+    border-bottom: none;
+    cursor: pointer;
+    color: var(--sh3-fg);
+  }
+  .tab-strip button.active { background: var(--sh3-bg); }
+  .body { flex: 1; min-height: 0; overflow: auto; }
+</style>

package/dist/overlays/DrawerSurface.svelte.d.ts

@@ -0,0 +1,12 @@
+import type { DrawerAnchor, DrawerSpec } from '../layout/compact/types';
+type $$ComponentProps = {
+    anchor: DrawerAnchor;
+    spec: DrawerSpec;
+    open: boolean;
+    activeSlotId: string | null;
+    onClose: () => void;
+    onActivate: (slotId: string) => void;
+};
+declare const DrawerSurface: import("svelte").Component<$$ComponentProps, {}, "">;
+type DrawerSurface = ReturnType<typeof DrawerSurface>;
+export default DrawerSurface;

package/dist/overlays/DrawerSurface.svelte.test.d.ts

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

package/dist/overlays/DrawerSurface.svelte.test.js

@@ -0,0 +1,67 @@
+/*
+ * DOM smoke test for DrawerSurface — when open with a single-slot spec,
+ * the drawer renders the slot's label in its header. When closed, it
+ * renders nothing.
+ *
+ * Re-parent contract testing (slot DOM container actually moves, doesn't
+ * remount) is handled by the browser-mode handheld-flip test.
+ */
+import { describe, it, expect, afterEach } from 'vitest';
+import { mount, unmount, flushSync } from 'svelte';
+import DrawerSurface from './DrawerSurface.svelte';
+const DrawerSurfaceAny = DrawerSurface;
+const spec = {
+    slots: [{ slotId: 'sb', viewId: 'v:sb', label: 'Files', role: 'sidebar' }],
+};
+const multiSpec = {
+    slots: [
+        { slotId: 'sb', viewId: 'v:sb', label: 'Files', role: 'sidebar' },
+        { slotId: 'pin', viewId: 'v:pin', label: 'Pinned', role: 'sidebar' },
+    ],
+};
+let mounted = null;
+let host = null;
+function renderHost(props) {
+    host = document.createElement('div');
+    host.style.position = 'relative';
+    document.body.appendChild(host);
+    mounted = mount(DrawerSurfaceAny, { target: host, props });
+    flushSync();
+    return host;
+}
+afterEach(() => {
+    if (mounted) {
+        unmount(mounted);
+        mounted = null;
+    }
+    if (host) {
+        host.remove();
+        host = null;
+    }
+});
+describe('DrawerSurface (dom)', () => {
+    it('renders nothing when closed', () => {
+        const el = renderHost({
+            anchor: 'left', spec, open: false, activeSlotId: null,
+            onClose: () => { }, onActivate: () => { },
+        });
+        expect(el.querySelector('[data-sh3-region="drawer"]')).toBeNull();
+    });
+    it('renders header with slot label when open', () => {
+        const el = renderHost({
+            anchor: 'left', spec, open: true, activeSlotId: 'sb',
+            onClose: () => { }, onActivate: () => { },
+        });
+        const header = el.querySelector('[data-sh3-region="drawer"] header');
+        expect(header === null || header === void 0 ? void 0 : header.textContent).toContain('Files');
+    });
+    it('multi-slot drawer renders a tab strip with one button per slot', () => {
+        const el = renderHost({
+            anchor: 'left', spec: multiSpec, open: true, activeSlotId: 'pin',
+            onClose: () => { }, onActivate: () => { },
+        });
+        const tabs = el.querySelectorAll('[data-sh3-region="drawer"] .tab-strip button');
+        expect(tabs.length).toBe(2);
+        expect(tabs[1].classList.contains('active')).toBe(true);
+    });
+});

package/dist/overlays/OverlayRoots.svelte

@@ -0,0 +1,89 @@
+<script lang="ts">
+  /*
+   * OverlayRoots — the six overlay-layer roots and the float-store binding,
+   * extracted so both the main shell (`Sh3.svelte`) and satellite shell
+   * (`SatelliteShell.svelte`) can mount them.
+   *
+   * Without this, satellite views can't open modals/popups/floats: layer
+   * managers call `getLayerRoot('modal')` and throw because no root was
+   * registered. Same situation for the float store binding the
+   * `FloatLayer` reads to render detached frames.
+   *
+   * Each layer is an absolutely-positioned full-window div with
+   * pointer-events: none; managers enable pointer events on the surfaces
+   * they portal in.
+   */
+
+  import DragPreview from '../layout/DragPreview.svelte';
+  import FloatLayer from './FloatLayer.svelte';
+  import { registerLayerRoot, unregisterLayerRoot } from './roots';
+  import { bindFloatStore, unbindFloatStore } from './float';
+  import { layoutStore } from '../layout/store.svelte';
+  import type { OverlayLayer } from './types';
+
+  // Layer metadata — order matches the stack in docs/design/layout.md.
+  // Index 0 here is layer 1 (floating panels); layer 0 is the content area.
+  // The 'drawers' layer (compact-mode side panels) sits between docked (0)
+  // and floating (1); its z-index comes from --sh3-z-layer-drawers.
+  const overlayLayers: { layer: number | string; name: OverlayLayer; zToken: string }[] = [
+    { layer: 'drawers',     name: 'drawers',      zToken: '--sh3-z-layer-drawers' },
+    { layer: 1, name: 'floating',     zToken: '--sh3-z-layer-1' },
+    { layer: 2, name: 'drag-preview', zToken: '--sh3-z-layer-2' },
+    { layer: 3, name: 'popup',        zToken: '--sh3-z-layer-3' },
+    { layer: 4, name: 'modal',        zToken: '--sh3-z-layer-4' },
+    { layer: 5, name: 'toast',        zToken: '--sh3-z-layer-5' },
+    { layer: 6, name: 'command',      zToken: '--sh3-z-layer-6' },
+  ];
+
+  const overlayRoots: Partial<Record<OverlayLayer, HTMLDivElement>> = $state({});
+
+  $effect(() => {
+    for (const { name } of overlayLayers) {
+      const el = overlayRoots[name];
+      if (el) registerLayerRoot(name, el);
+    }
+    return () => {
+      for (const { name } of overlayLayers) unregisterLayerRoot(name);
+    };
+  });
+
+  $effect(() => {
+    const tree = layoutStore.tree;
+    bindFloatStore(tree.floats, () => ({
+      w: window.innerWidth,
+      h: window.innerHeight,
+    }));
+    return () => unbindFloatStore();
+  });
+</script>
+
+<div class="sh3-overlays" aria-hidden="true">
+  {#each overlayLayers as { layer, name, zToken } (layer)}
+    <div
+      class="sh3-overlay-root"
+      data-sh3-overlay={name}
+      data-sh3-layer={layer}
+      style="z-index: var({zToken});"
+      bind:this={overlayRoots[name]}
+    >
+      {#if name === 'floating'}
+        <FloatLayer />
+      {:else if name === 'drag-preview'}
+        <DragPreview />
+      {/if}
+    </div>
+  {/each}
+</div>
+
+<style>
+  .sh3-overlays {
+    position: absolute;
+    inset: 0;
+    pointer-events: none;
+  }
+  .sh3-overlay-root {
+    position: absolute;
+    inset: 0;
+    pointer-events: none;
+  }
+</style>

package/dist/overlays/OverlayRoots.svelte.d.ts

@@ -0,0 +1,3 @@
+declare const OverlayRoots: import("svelte").Component<Record<string, never>, {}, "">;
+type OverlayRoots = ReturnType<typeof OverlayRoots>;
+export default OverlayRoots;

package/dist/overlays/types.d.ts

@@ -1,4 +1,4 @@
-export type OverlayLayer = 'floating' | 'drag-preview' | 'popup' | 'modal' | 'toast' | 'command';
+export type OverlayLayer = 'drawers' | 'floating' | 'drag-preview' | 'popup' | 'modal' | 'toast' | 'command';
 /** A handle returned by every overlay opener. Calling close() is idempotent. */
 export interface OverlayHandle {
     close(): void;

package/dist/platform/tauri-backend.d.ts

@@ -7,9 +7,9 @@ export declare class TauriStoreBackend implements Backend {
     delete(shardId: string): void;
     list(): string[];
     /**
-     * Load the store from disk into the local cache. Must be called once
-     * before read/list return meaningful data. Called by the platform
-     * resolver at boot.
+     * Load the store from disk into the local cache and start mirroring
+     * cross-window writes. Must be called once before read/list return
+     * meaningful data. Called by the platform resolver at boot.
      */
     init(): Promise<void>;
 }

package/dist/platform/tauri-backend.js

@@ -8,6 +8,15 @@
  * init(), then serve reads/lists synchronously from that cache —
  * matching the Backend interface contract. Writes go to both the
  * local cache and the Tauri store (fire-and-forget async).
+ *
+ * Multi-window coherence: each Tauri WebviewWindow runs its own JS
+ * context, so each gets its own TauriStoreBackend instance with an
+ * independent #cache. Without coordination, a satellite window booted
+ * from the host would never see writes made in the host (or vice
+ * versa). init() subscribes to plugin-store's onChange event so any
+ * cross-window write is mirrored into the local cache. The same event
+ * fires for this window's own writes too, but the cache.set there is
+ * idempotent.
  */
 var __classPrivateFieldSet = (this && this.__classPrivateFieldSet) || function (receiver, state, value, kind, f) {
     if (kind === "m") throw new TypeError("Private method is not writable");
@@ -44,15 +53,27 @@ export class TauriStoreBackend {
         return [...__classPrivateFieldGet(this, _TauriStoreBackend_cache, "f").keys()];
     }
     /**
-     * Load the store from disk into the local cache. Must be called once
-     * before read/list return meaningful data. Called by the platform
-     * resolver at boot.
+     * Load the store from disk into the local cache and start mirroring
+     * cross-window writes. Must be called once before read/list return
+     * meaningful data. Called by the platform resolver at boot.
      */
     async init() {
         const entries = await __classPrivateFieldGet(this, _TauriStoreBackend_store, "f").entries();
         for (const [key, value] of entries) {
             __classPrivateFieldGet(this, _TauriStoreBackend_cache, "f").set(key, value);
         }
+        // Mirror writes from other WebviewWindows (and our own) into the
+        // local cache so reads stay coherent across the host + satellites.
+        // The unlisten fn is intentionally not retained — the backend lives
+        // for the page session and the subscription tears down with it.
+        await __classPrivateFieldGet(this, _TauriStoreBackend_store, "f").onChange((key, value) => {
+            if (value === undefined) {
+                __classPrivateFieldGet(this, _TauriStoreBackend_cache, "f").delete(key);
+            }
+            else {
+                __classPrivateFieldGet(this, _TauriStoreBackend_cache, "f").set(key, value);
+            }
+        });
     }
 }
 _TauriStoreBackend_store = new WeakMap(), _TauriStoreBackend_cache = new WeakMap();

package/dist/projects/session-state.svelte.d.ts

@@ -10,8 +10,8 @@ export declare const sessionState: {
  *
  * Setting the same value is a no-op (no app unload, no breadcrumb clear).
  *
- * The unloadApp call is deferred to a dynamic import so this module stays
- * importable from circular-dependency hot-paths (lifecycle imports
- * sessionState; sessionState here would otherwise import lifecycle eagerly).
+ * Note: lifecycle ↔ session-state is a circular import. Safe because both
+ * sides only read the imported binding inside function bodies, after module
+ * init completes.
  */
 export declare function setActiveProjectId(id: string | null): void;

package/dist/projects/session-state.svelte.js

@@ -11,6 +11,7 @@
  * active app (whose scopeId is bound to the old scope).
  */
 import { activeApp, breadcrumbApp } from '../apps/registry.svelte';
+import { unloadApp } from '../apps/lifecycle';
 export const sessionState = $state({
     activeProjectId: null,
 });
@@ -23,9 +24,9 @@ export const sessionState = $state({
  *
  * Setting the same value is a no-op (no app unload, no breadcrumb clear).
  *
- * The unloadApp call is deferred to a dynamic import so this module stays
- * importable from circular-dependency hot-paths (lifecycle imports
- * sessionState; sessionState here would otherwise import lifecycle eagerly).
+ * Note: lifecycle ↔ session-state is a circular import. Safe because both
+ * sides only read the imported binding inside function bodies, after module
+ * init completes.
  */
 export function setActiveProjectId(id) {
     if (sessionState.activeProjectId === id)
@@ -34,6 +35,6 @@ export function setActiveProjectId(id) {
     sessionState.activeProjectId = id;
     breadcrumbApp.id = null;
     if (previousActive) {
-        void import('../apps/lifecycle').then((m) => m.unloadApp(previousActive));
+        unloadApp(previousActive);
     }
 }

package/dist/runtime/runVerb.js

@@ -17,7 +17,7 @@
  */
 import { activeShards } from '../shards/activate.svelte';
 import { getVerb, listVerbsWithShard } from '../shards/registry';
-import { makeSh3ApiHeadless } from '../sh3Api/headless';
+import { makeSh3Api } from '../sh3Api/headless';
 import { Scrollback } from '../shell-shard/scrollback.svelte';
 import { SessionClient } from '../shell-shard/session-client.svelte';
 import { TenantFsClient } from '../shell-shard/tenant-fs-client';
@@ -53,7 +53,7 @@ export async function runVerbProgrammatic(shardId, name, args, opts) {
 async function buildProgrammaticContext(b) {
     var _a, _b;
     const ctx = {
-        sh3: makeSh3ApiHeadless(),
+        sh3: makeSh3Api({ callerKind: 'verb' }),
         scrollback: b.sinkScrollback,
         session: makeStubSession(),
         cwd: '/',

package/dist/satellite/SatelliteShell.svelte

@@ -3,22 +3,23 @@
    * SatelliteShell — top-level root component mounted by createShell() when
    * detectSatelliteMode() returns a payload.
    *
-   * Renders only LayoutRenderer against the seeded in-memory layout. No brand
-   * bar, no home button, no overlay chrome. The workspace zone backend has
-   * already been forced to MemoryBackend by createShell() before this mounts.
-   *
-   * Float payloads: seeds HOME_TREE's docked node directly via
-   *   seedSatelliteLayout(), so LayoutRenderer immediately shows the detached
+   * Float payloads: chromeless. Seeds HOME_TREE's docked node directly via
+   *   seedSatelliteLayout() so LayoutRenderer immediately shows the detached
    *   float content.
    *
-   * App payloads: kicks off launchApp(appId, { skipLastApp, skipSwitchToHome })
-   *   which handles the full attach/switchToApp lifecycle. The seed call is
-   *   skipped because launchApp replaces the active root to 'app' on its own.
+   * App payloads: renders a slim tabbar (BrandSlot + MenuBar + reserved
+   *   minimized-floats slot) above LayoutRenderer, then kicks off
+   *   launchApp(appId, { skipLastApp, skipSwitchToHome }) which handles the
+   *   full attach + required-shard activation lifecycle. Home button is
+   *   intentionally omitted — the OS window close is the satellite's "home".
    */
 
   import '../tokens.css';
   import '../primitives/base.css';
   import LayoutRenderer from '../layout/LayoutRenderer.svelte';
+  import OverlayRoots from '../overlays/OverlayRoots.svelte';
+  import BrandSlot from '../BrandSlot.svelte';
+  import MenuBar from '../actions/MenuBar.svelte';
   import { seedSatelliteLayout } from '../layout/store.svelte';
   import { seedLayoutFromPayload } from './seed';
   import { launchApp } from '../apps/lifecycle';
@@ -45,8 +46,20 @@
   });
 </script>
 
-<div class="sh3-satellite-root">
-  <LayoutRenderer />
+<div class="sh3-satellite-root" class:sh3-satellite-app={payload.kind === 'app'}>
+  {#if payload.kind === 'app'}
+    <header class="sh3-satellite-tabbar" data-sh3-region="tabbar">
+      <BrandSlot />
+      <MenuBar />
+      <div class="sh3-satellite-floats-slot" aria-hidden="true"></div>
+    </header>
+    <main class="sh3-satellite-content" data-sh3-region="content" data-sh3-layer="0">
+      <LayoutRenderer />
+    </main>
+  {:else}
+    <LayoutRenderer />
+  {/if}
+  <OverlayRoots />
 </div>
 
 <style>
@@ -57,4 +70,38 @@
     background: var(--sh3-grad-bg, var(--sh3-bg));
     color: var(--sh3-fg);
   }
+
+  /*
+   * App-payload satellites get a slim chrome row above the content. Float
+   * payloads keep the original full-bleed layout (no grid, content fills
+   * the root), so the .sh3-satellite-app modifier is required for the grid.
+   */
+  .sh3-satellite-root.sh3-satellite-app {
+    display: grid;
+    grid-template-rows: var(--sh3-tabbar-height) 1fr;
+  }
+
+  .sh3-satellite-tabbar {
+    display: grid;
+    grid-template-columns: auto 1fr auto;
+    align-items: center;
+    gap: var(--sh3-pad-md);
+    padding: 0 var(--sh3-pad-md);
+    background: var(--sh3-grad-bg-elevated, var(--sh3-bg-elevated));
+    border-bottom: 1px solid var(--sh3-border);
+    user-select: none;
+  }
+
+  .sh3-satellite-content {
+    position: relative;
+    overflow: hidden;
+    background: var(--sh3-grad-bg, var(--sh3-bg));
+    min-width: 0;
+    min-height: 0;
+  }
+
+  .sh3-satellite-floats-slot {
+    /* Reserved cell for future minimized-float chips; empty for now. */
+    min-width: 0;
+  }
 </style>

package/dist/satellite/SatelliteShell.svelte.test.d.ts

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

package/dist/satellite/SatelliteShell.svelte.test.js

@@ -0,0 +1,61 @@
+import { describe, it, expect, beforeEach } from 'vitest';
+import { tick } from 'svelte';
+import SatelliteShell from './SatelliteShell.svelte';
+import { resetFramework } from '../__test__/reset';
+import { renderWithShell } from '../__test__/render';
+import { makeApp, makeAppManifest, makeSlotNode, makeTree, } from '../__test__/fixtures';
+import { registerApp } from '../apps/registry.svelte';
+import { registerView } from '../shards/registry';
+function registerStubView() {
+    registerView('test:view', {
+        mount(container, ctx) {
+            const node = document.createElement('div');
+            node.dataset.viewFor = ctx.slotId;
+            container.appendChild(node);
+            return { unmount: () => node.remove() };
+        },
+    });
+}
+describe('SatelliteShell — chrome rendering', () => {
+    beforeEach(resetFramework);
+    it('renders BrandSlot + MenuBar + reserved floats slot for app payloads', async () => {
+        registerStubView();
+        registerApp(makeApp({
+            manifest: makeAppManifest({
+                id: 'sat-app',
+                label: 'Sat App',
+            }),
+            initialLayout: [
+                { name: 'default', tree: makeTree(makeSlotNode('s', 'test:view')) },
+            ],
+        }));
+        const payload = {
+            kind: 'app',
+            appId: 'sat-app',
+            activateShards: [],
+        };
+        const { container } = renderWithShell(SatelliteShell, { payload });
+        // launchApp runs in queueMicrotask inside the $effect; flush both.
+        await Promise.resolve();
+        await tick();
+        await tick();
+        expect(container.querySelector('[data-sh3-region="tabbar"]')).toBeTruthy();
+        expect(container.querySelector('.sh3-brand-slot')).toBeTruthy();
+        expect(container.querySelector('[role="menubar"]')).toBeTruthy();
+        expect(container.querySelector('.sh3-satellite-floats-slot')).toBeTruthy();
+    });
+    it('renders no tabbar / chrome for float payloads', async () => {
+        const payload = {
+            kind: 'float',
+            content: makeSlotNode('s', 'test:view'),
+            size: { w: 800, h: 600 },
+            activateShards: [],
+        };
+        const { container } = renderWithShell(SatelliteShell, { payload });
+        await tick();
+        expect(container.querySelector('[data-sh3-region="tabbar"]')).toBeFalsy();
+        expect(container.querySelector('.sh3-brand-slot')).toBeFalsy();
+        expect(container.querySelector('[role="menubar"]')).toBeFalsy();
+        expect(container.querySelector('.sh3-satellite-floats-slot')).toBeFalsy();
+    });
+});

package/dist/sh3Api/fields-walker.svelte.test.d.ts

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