sh3-core 0.16.1 → 0.17.2

package/dist/chrome/MenuSheet.svelte

@@ -0,0 +1,224 @@
+<script lang="ts">
+  /*
+   * Touch-friendly replacement for MenuBar — bottom-anchored sheet with
+   * collapsible sections per menu container. Tapping a submenu parent
+   * expands its children inline (no nested popover stack — see
+   * docs/superpowers/specs/2026-05-09-action-submenu-discoverability-design.md).
+   *
+   * Reads the same dispatcher state and registry as MenuBar:
+   *   resolveMenuContainers(activeAppId, declared)
+   *   resolveMenuItems(entries, dispatcherState, containerId)
+   *   resolveSubmenuItems(entries, dispatcherState, parentId)
+   */
+  import {
+    resolveMenuContainers,
+    resolveMenuItems,
+    resolveSubmenuItems,
+    type MenuBarItem,
+  } from '../actions/menuBarModel';
+  import { listActions } from '../actions/registry';
+  import { getLiveDispatcherState } from '../actions/state.svelte';
+  import { getRegisteredApp } from '../apps/registry.svelte';
+  import { resolveLabel } from '../actions/types';
+
+  let { open, onClose }: { open: boolean; onClose: () => void } = $props();
+
+  const dispatcher = $derived(getLiveDispatcherState());
+  const activeAppId = $derived(dispatcher.activeAppId);
+  const declaredMenus = $derived.by(() => {
+    if (!activeAppId) return undefined;
+    return getRegisteredApp(activeAppId)?.manifest.menus;
+  });
+  const containers = $derived(resolveMenuContainers(activeAppId, declaredMenus));
+  const containerItems = $derived.by(() => {
+    const out: { containerId: string; label: string; items: MenuBarItem[] }[] = [];
+    const entries = listActions();
+    for (const c of containers) {
+      const items = resolveMenuItems(entries, dispatcher, c.id);
+      if (items.length > 0) out.push({ containerId: c.id, label: c.label, items });
+    }
+    return out;
+  });
+
+  let expanded = $state(new Set<string>());
+  let expandedSubmenu = $state(new Set<string>());
+
+  function toggleContainer(id: string) {
+    const next = new Set(expanded);
+    if (next.has(id)) next.delete(id);
+    else next.add(id);
+    expanded = next;
+  }
+
+  function toggleSubmenu(id: string) {
+    const next = new Set(expandedSubmenu);
+    if (next.has(id)) next.delete(id);
+    else next.add(id);
+    expandedSubmenu = next;
+  }
+
+  function invoke(itemId: string) {
+    const entry = listActions().find((e) => e.action.id === itemId);
+    if (!entry || typeof entry.action.run !== 'function') return;
+    try {
+      void entry.action.run({
+        action: { id: itemId, label: resolveLabel(entry.action) },
+        appId: dispatcher.activeAppId,
+        viewId: dispatcher.focusedViewId ?? undefined,
+        selection: dispatcher.selection ?? undefined,
+        invokedVia: 'palette',
+        dispatch: () => {},
+      });
+    } catch (err) {
+      console.error(`[sh3] menu-sheet action "${itemId}" threw:`, err);
+    }
+    onClose();
+  }
+</script>
+
+{#if open}
+  <div
+    class="backdrop"
+    onclick={onClose}
+    onkeydown={(e) => { if (e.key === 'Escape') onClose(); }}
+    role="presentation"
+  ></div>
+  <div class="sheet" role="dialog" aria-label="Menu" data-sh3-region="menu-sheet">
+    <div class="scroll">
+      {#each containerItems as { containerId, label, items } (containerId)}
+        <button
+          class="container"
+          aria-expanded={expanded.has(containerId)}
+          onclick={() => toggleContainer(containerId)}
+        >
+          <span class="caret" class:open={expanded.has(containerId)}>▸</span>
+          <span class="label">{label}</span>
+        </button>
+        {#if expanded.has(containerId)}
+          <div class="items">
+            {#each items as item (item.id)}
+              {#if item.submenu}
+                <button
+                  class="item submenu"
+                  aria-expanded={expandedSubmenu.has(item.id)}
+                  disabled={item.disabled}
+                  onclick={() => toggleSubmenu(item.id)}
+                >
+                  <span class="caret" class:open={expandedSubmenu.has(item.id)}>▸</span>
+                  <span class="label">{item.label}</span>
+                </button>
+                {#if expandedSubmenu.has(item.id)}
+                  <div class="subitems">
+                    {#each resolveSubmenuItems(listActions(), dispatcher, item.id) as sub (sub.id)}
+                      <button
+                        class="item child"
+                        disabled={sub.disabled}
+                        onclick={() => invoke(sub.id)}
+                      >
+                        <span class="label">{sub.label}</span>
+                        {#if sub.shortcut}
+                          <span class="shortcut">{sub.shortcut}</span>
+                        {/if}
+                      </button>
+                    {/each}
+                  </div>
+                {/if}
+              {:else}
+                <button
+                  class="item"
+                  disabled={item.disabled}
+                  onclick={() => invoke(item.id)}
+                >
+                  <span class="label">{item.label}</span>
+                  {#if item.shortcut}
+                    <span class="shortcut">{item.shortcut}</span>
+                  {/if}
+                </button>
+              {/if}
+            {/each}
+          </div>
+        {/if}
+      {/each}
+    </div>
+    <button class="cancel" onclick={onClose}>Cancel</button>
+  </div>
+{/if}
+
+<style>
+  .backdrop {
+    position: absolute;
+    inset: 0;
+    background: var(--sh3-overlay-backdrop, rgba(0, 0, 0, 0.35));
+    pointer-events: auto;
+    z-index: var(--sh3-z-layer-4);
+  }
+  .sheet {
+    position: absolute;
+    left: 0;
+    right: 0;
+    bottom: 0;
+    max-height: 70vh;
+    display: flex;
+    flex-direction: column;
+    background: var(--sh3-bg);
+    color: var(--sh3-fg);
+    border-top: 1px solid var(--sh3-border);
+    box-shadow: var(--sh3-shadow-md, 0 -4px 16px rgba(0, 0, 0, 0.2));
+    pointer-events: auto;
+    z-index: var(--sh3-z-layer-4);
+  }
+  .scroll {
+    flex: 1;
+    min-height: 0;
+    overflow: auto;
+    padding: var(--sh3-pad-sm) 0;
+  }
+  .container {
+    display: flex;
+    align-items: center;
+    gap: var(--sh3-pad-sm);
+    width: 100%;
+    padding: var(--sh3-pad-sm) var(--sh3-pad-md);
+    border: none;
+    background: none;
+    color: var(--sh3-fg);
+    font-weight: 600;
+    text-align: left;
+    cursor: pointer;
+  }
+  .container:active { background: var(--sh3-bg-sunken); }
+  .items { padding-left: var(--sh3-pad-md); }
+  .subitems { padding-left: var(--sh3-pad-md); }
+  .item {
+    display: flex;
+    align-items: center;
+    gap: var(--sh3-pad-sm);
+    width: 100%;
+    padding: var(--sh3-pad-sm) var(--sh3-pad-md);
+    border: none;
+    background: none;
+    color: var(--sh3-fg);
+    text-align: left;
+    cursor: pointer;
+  }
+  .item:disabled { opacity: 0.5; cursor: not-allowed; }
+  .item:active:not(:disabled) { background: var(--sh3-bg-sunken); }
+  .item.child { padding-left: calc(var(--sh3-pad-md) * 2); }
+  .label { flex: 1; }
+  .shortcut { color: var(--sh3-fg-muted); font-family: var(--sh3-font-mono); }
+  .caret {
+    display: inline-block;
+    width: 1em;
+    transition: transform 120ms;
+  }
+  .caret.open { transform: rotate(90deg); }
+  .cancel {
+    padding: var(--sh3-pad-md);
+    border: none;
+    border-top: 1px solid var(--sh3-border);
+    background: var(--sh3-bg-elevated);
+    color: var(--sh3-fg);
+    font-weight: 600;
+    cursor: pointer;
+  }
+</style>

package/dist/chrome/MenuSheet.svelte.d.ts

@@ -0,0 +1,7 @@
+type $$ComponentProps = {
+    open: boolean;
+    onClose: () => void;
+};
+declare const MenuSheet: import("svelte").Component<$$ComponentProps, {}, "">;
+type MenuSheet = ReturnType<typeof MenuSheet>;
+export default MenuSheet;

package/dist/chrome/MenuSheet.svelte.test.d.ts

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

package/dist/chrome/MenuSheet.svelte.test.js

@@ -0,0 +1,46 @@
+/*
+ * DOM smoke for MenuSheet — verifies open/closed rendering. The
+ * container/item resolution is exercised via the same model functions
+ * MenuBar uses; their unit tests cover the resolution semantics so
+ * this test only asserts the wrapper structure.
+ */
+import { describe, it, expect, afterEach } from 'vitest';
+import { mount, unmount, flushSync } from 'svelte';
+import MenuSheet from './MenuSheet.svelte';
+const MenuSheetAny = MenuSheet;
+let mounted = null;
+let host = null;
+afterEach(() => {
+    if (mounted) {
+        unmount(mounted);
+        mounted = null;
+    }
+    if (host) {
+        host.remove();
+        host = null;
+    }
+});
+describe('MenuSheet (dom)', () => {
+    it('renders nothing when closed', () => {
+        host = document.createElement('div');
+        document.body.appendChild(host);
+        mounted = mount(MenuSheetAny, {
+            target: host,
+            props: { open: false, onClose: () => { } },
+        });
+        flushSync();
+        expect(host.querySelector('[data-sh3-region="menu-sheet"]')).toBeNull();
+    });
+    it('renders a sheet with a Cancel button when open', () => {
+        host = document.createElement('div');
+        document.body.appendChild(host);
+        mounted = mount(MenuSheetAny, {
+            target: host,
+            props: { open: true, onClose: () => { } },
+        });
+        flushSync();
+        const sheet = host.querySelector('[data-sh3-region="menu-sheet"]');
+        expect(sheet).not.toBeNull();
+        expect(sheet.querySelector('.cancel').textContent).toContain('Cancel');
+    });
+});

package/dist/contributions/index.d.ts

@@ -1,2 +1,2 @@
 export type { ContributionsApi } from './types';
-export { register, list, listPoints, onChange, onAnyChange, __resetContributionsForTest } from './registry';
+export { register, list, listPoints, onChange, onAnyChange, __disposeSlotContributions, __resetContributionsForTest, } from './registry';

package/dist/contributions/index.js

@@ -5,4 +5,4 @@
  * file is internal-only, re-exporting the registry for activate.svelte.ts
  * and for tests.
  */
-export { register, list, listPoints, onChange, onAnyChange, __resetContributionsForTest } from './registry';
+export { register, list, listPoints, onChange, onAnyChange, __disposeSlotContributions, __resetContributionsForTest, } from './registry';

package/dist/contributions/registry.d.ts

@@ -1,8 +1,18 @@
 /**
  * Register a descriptor under the given point. Returns an unregister
  * function; calling it more than once is a safe no-op.
+ *
+ * Pass `opts.scope.slotId` to tie cleanup to a slot's lifecycle:
+ * `__disposeSlotContributions(slotId)` will fire the disposer on slot
+ * unmount. The disposer is idempotent — manual dispose detaches it from
+ * the slot bag, so a later slot-cleanup pass becomes a no-op for that
+ * entry.
  */
-export declare function register<T = unknown>(pointId: string, descriptor: T): () => void;
+export declare function register<T = unknown>(pointId: string, descriptor: T, opts?: {
+    scope?: {
+        slotId?: string;
+    };
+}): () => void;
 /** Enumerate descriptors at the named point in registration order. */
 export declare function list<T = unknown>(pointId: string): T[];
 /** Enumerate every point id with at least one registration. */
@@ -21,6 +31,12 @@ export declare function onChange(pointId: string, cb: () => void): () => void;
  * safe no-op. Symmetric with `onChange`, but global.
  */
 export declare function onAnyChange(cb: (pointId: string) => void): () => void;
+/**
+ * Drain every disposer registered with `scope.slotId === slotId`. Safe
+ * to call on unknown slot ids. Used by the layout module on slot unmount
+ * to release contributions tied to that slot's lifetime.
+ */
+export declare function __disposeSlotContributions(slotId: string): void;
 /**
  * Test-only reset. Not exported from the barrel; tests import it
  * directly from this module.

package/dist/contributions/registry.js

@@ -13,6 +13,7 @@
 const points = new Map();
 const listeners = new Map();
 const anyListeners = new Set();
+const slotCleanup = new Map();
 function emit(pointId) {
     const set = listeners.get(pointId);
     if (set) {
@@ -22,11 +23,34 @@ function emit(pointId) {
     for (const cb of anyListeners)
         cb(pointId);
 }
+function attachToSlot(slotId, dispose) {
+    let bag = slotCleanup.get(slotId);
+    if (!bag) {
+        bag = new Set();
+        slotCleanup.set(slotId, bag);
+    }
+    bag.add(dispose);
+}
+function detachFromSlot(slotId, dispose) {
+    const bag = slotCleanup.get(slotId);
+    if (!bag)
+        return;
+    bag.delete(dispose);
+    if (bag.size === 0)
+        slotCleanup.delete(slotId);
+}
 /**
  * Register a descriptor under the given point. Returns an unregister
  * function; calling it more than once is a safe no-op.
+ *
+ * Pass `opts.scope.slotId` to tie cleanup to a slot's lifecycle:
+ * `__disposeSlotContributions(slotId)` will fire the disposer on slot
+ * unmount. The disposer is idempotent — manual dispose detaches it from
+ * the slot bag, so a later slot-cleanup pass becomes a no-op for that
+ * entry.
  */
-export function register(pointId, descriptor) {
+export function register(pointId, descriptor, opts) {
+    var _a;
     const handle = Symbol();
     let map = points.get(pointId);
     if (!map) {
@@ -35,11 +59,14 @@ export function register(pointId, descriptor) {
     }
     map.set(handle, descriptor);
     emit(pointId);
+    const slotId = (_a = opts === null || opts === void 0 ? void 0 : opts.scope) === null || _a === void 0 ? void 0 : _a.slotId;
     let disposed = false;
-    return () => {
+    const dispose = () => {
         if (disposed)
             return;
         disposed = true;
+        if (slotId)
+            detachFromSlot(slotId, dispose);
         const m = points.get(pointId);
         if (!m)
             return;
@@ -49,6 +76,9 @@ export function register(pointId, descriptor) {
             emit(pointId);
         }
     };
+    if (slotId)
+        attachToSlot(slotId, dispose);
+    return dispose;
 }
 /** Enumerate descriptors at the named point in registration order. */
 export function list(pointId) {
@@ -98,6 +128,23 @@ export function onAnyChange(cb) {
         anyListeners.delete(cb);
     };
 }
+/**
+ * Drain every disposer registered with `scope.slotId === slotId`. Safe
+ * to call on unknown slot ids. Used by the layout module on slot unmount
+ * to release contributions tied to that slot's lifetime.
+ */
+export function __disposeSlotContributions(slotId) {
+    const bag = slotCleanup.get(slotId);
+    if (!bag)
+        return;
+    // Snapshot before iterating: each dispose detaches itself from the bag
+    // via detachFromSlot, which mutates the live set.
+    const snapshot = Array.from(bag);
+    for (const dispose of snapshot)
+        dispose();
+    // detachFromSlot already removes empty bags, but be explicit.
+    slotCleanup.delete(slotId);
+}
 /**
  * Test-only reset. Not exported from the barrel; tests import it
  * directly from this module.
@@ -106,4 +153,5 @@ export function __resetContributionsForTest() {
     points.clear();
     listeners.clear();
     anyListeners.clear();
+    slotCleanup.clear();
 }

package/dist/contributions/scope.test.d.ts

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

package/dist/contributions/scope.test.js

@@ -0,0 +1,52 @@
+import { describe, it, expect, beforeEach, vi } from 'vitest';
+import { register, list, onChange, __disposeSlotContributions, __resetContributionsForTest, } from './registry';
+describe('contributions slot scope', () => {
+    beforeEach(() => {
+        __resetContributionsForTest();
+    });
+    it('register without scope behaves exactly as before', () => {
+        const dispose = register('p', { id: 'a' });
+        expect(list('p')).toEqual([{ id: 'a' }]);
+        dispose();
+        expect(list('p')).toEqual([]);
+    });
+    it('register with slot scope is reachable like any contribution', () => {
+        register('p', { id: 'a' }, { scope: { slotId: 's1' } });
+        expect(list('p')).toEqual([{ id: 'a' }]);
+    });
+    it('__disposeSlotContributions drains only the targeted slot', () => {
+        register('p', { id: 'a-s1' }, { scope: { slotId: 's1' } });
+        register('p', { id: 'b-s1' }, { scope: { slotId: 's1' } });
+        register('p', { id: 'c-s2' }, { scope: { slotId: 's2' } });
+        register('p', { id: 'd-noscope' });
+        __disposeSlotContributions('s1');
+        const remaining = list('p').map((d) => d.id).sort();
+        expect(remaining).toEqual(['c-s2', 'd-noscope']);
+    });
+    it('__disposeSlotContributions on unknown slot is a no-op', () => {
+        register('p', { id: 'a' }, { scope: { slotId: 's1' } });
+        expect(() => __disposeSlotContributions('s999')).not.toThrow();
+        expect(list('p')).toEqual([{ id: 'a' }]);
+    });
+    it('manually calling the disposer first makes __disposeSlotContributions a no-op for that entry', () => {
+        const dispose = register('p', { id: 'a' }, { scope: { slotId: 's1' } });
+        dispose();
+        expect(() => __disposeSlotContributions('s1')).not.toThrow();
+        expect(list('p')).toEqual([]);
+    });
+    it('double-dispose is idempotent', () => {
+        const dispose = register('p', { id: 'a' }, { scope: { slotId: 's1' } });
+        dispose();
+        dispose();
+        expect(list('p')).toEqual([]);
+    });
+    it('slot cleanup fires onChange for the affected pointId', () => {
+        const cb = vi.fn();
+        onChange('p', cb);
+        register('p', { id: 'a' }, { scope: { slotId: 's1' } });
+        expect(cb).toHaveBeenCalledTimes(1);
+        cb.mockClear();
+        __disposeSlotContributions('s1');
+        expect(cb).toHaveBeenCalledTimes(1);
+    });
+});

package/dist/contributions/types.d.ts

@@ -5,11 +5,19 @@ export interface ContributionsApi {
      * for ergonomics — provider and contributor agree on the shape via
      * a type-only import of the provider's public types.
      *
+     * Pass `opts.scope.slotId` to tie cleanup to a slot's lifecycle: the
+     * disposer will fire on slot unmount in addition to shard deactivate.
+     * Whichever fires first wins; the disposer is idempotent.
+     *
      * Returns an unregister function. Calling it is optional (the
-     * framework auto-unregisters on shard deactivate) and safe to call
-     * more than once.
+     * framework auto-unregisters on shard deactivate, and on slot unmount
+     * when scoped) and safe to call more than once.
      */
-    register<T = unknown>(pointId: string, descriptor: T): () => void;
+    register<T = unknown>(pointId: string, descriptor: T, opts?: {
+        scope?: {
+            slotId?: string;
+        };
+    }): () => void;
     /** Enumerate descriptors at `pointId` in registration order. */
     list<T = unknown>(pointId: string): T[];
     /** Enumerate every point id with at least one registration. */

package/dist/createShell.js

@@ -70,8 +70,14 @@ export async function createShell(config) {
         // via /api/packages aren't in IndexedDB on the satellite's view of the
         // world unless we fetch and register them, same as the main path.
         await loadDiscoveredPackages(config === null || config === void 0 ? void 0 : config.discoveredPackages);
+        // For app payloads, defer required-shard activation to launchApp so it
+        // runs *after* attachApp() binds the preset manager + slot holds. The
+        // payload's activateShards (manifest.requiredShards) are still carried
+        // for diagnostics, but launchApp drives activation in the same order
+        // as the host bootstrap. Float payloads have no launchApp so the walked
+        // view-providing shards must still activate here.
         await bootstrapSatellite({
-            activateShardIds: satellite.payload.activateShards,
+            activateShardIds: satellite.payload.kind === 'app' ? [] : satellite.payload.activateShards,
         });
         attachGlobalListeners();
         mount(SatelliteShell, { target, props: { payload: satellite.payload } });

package/dist/fields/address.d.ts

@@ -0,0 +1,3 @@
+import type { FieldAddress } from './types';
+export declare function fieldAddressToString(a: FieldAddress): string;
+export declare function fieldAddressFromString(s: string): FieldAddress;

package/dist/fields/address.js

@@ -0,0 +1,36 @@
+const ID_RE = /^[a-zA-Z0-9.\-_]+$/;
+const SLOT_RE = /^[a-zA-Z0-9.\-_]*$/; // slotId may be empty in the wire form
+function validateIdPart(value, partName) {
+    if (value.length === 0)
+        throw new Error(`fieldAddress: ${partName} is empty`);
+    if (!ID_RE.test(value)) {
+        throw new Error(`fieldAddress: invalid ${partName} "${value}" (must match [a-zA-Z0-9.\\-_]+)`);
+    }
+}
+function validateSlotPart(value) {
+    if (!SLOT_RE.test(value)) {
+        throw new Error(`fieldAddress: invalid slotId "${value}"`);
+    }
+}
+export function fieldAddressToString(a) {
+    var _a;
+    validateIdPart(a.shardId, 'shardId');
+    validateIdPart(a.fieldId, 'fieldId');
+    if (a.slotId !== undefined)
+        validateSlotPart(a.slotId);
+    return `${a.shardId}::${(_a = a.slotId) !== null && _a !== void 0 ? _a : ''}::${a.fieldId}`;
+}
+export function fieldAddressFromString(s) {
+    const parts = s.split('::');
+    if (parts.length !== 3) {
+        throw new Error(`fieldAddress: malformed "${s}" (expected three ::-separated parts)`);
+    }
+    const [shardId, slotPart, fieldId] = parts;
+    validateIdPart(shardId, 'shardId');
+    validateIdPart(fieldId, 'fieldId');
+    validateSlotPart(slotPart);
+    const out = { shardId, fieldId };
+    if (slotPart.length > 0)
+        out.slotId = slotPart;
+    return out;
+}

package/dist/fields/address.test.d.ts

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

package/dist/fields/address.test.js

@@ -0,0 +1,34 @@
+import { describe, it, expect } from 'vitest';
+import { fieldAddressToString, fieldAddressFromString } from './address';
+describe('fieldAddress codec', () => {
+    it('roundtrips a slot-scoped address', () => {
+        const a = { shardId: 'editor', slotId: 'slot-1', fieldId: 'title' };
+        expect(fieldAddressFromString(fieldAddressToString(a))).toEqual(a);
+    });
+    it('roundtrips a shard-scoped address (slotId absent)', () => {
+        const a = { shardId: 'settings', fieldId: 'theme' };
+        expect(fieldAddressFromString(fieldAddressToString(a))).toEqual(a);
+    });
+    it('serializes shard-scoped as <shardId>::<empty>::<fieldId>', () => {
+        expect(fieldAddressToString({ shardId: 's', fieldId: 'f' })).toBe('s::::f');
+    });
+    it('serializes slot-scoped as <shardId>::<slotId>::<fieldId>', () => {
+        expect(fieldAddressToString({ shardId: 's', slotId: 'sl', fieldId: 'f' })).toBe('s::sl::f');
+    });
+    it('rejects malformed input — too few parts', () => {
+        expect(() => fieldAddressFromString('s::sl')).toThrow(/malformed/);
+    });
+    it('rejects malformed input — too many parts', () => {
+        expect(() => fieldAddressFromString('s::sl::f::extra')).toThrow(/malformed/);
+    });
+    it('rejects an empty shardId', () => {
+        expect(() => fieldAddressFromString('::sl::f')).toThrow(/shardId/);
+    });
+    it('rejects an empty fieldId', () => {
+        expect(() => fieldAddressFromString('s::sl::')).toThrow(/fieldId/);
+    });
+    it('rejects characters outside [a-zA-Z0-9.\\-_]', () => {
+        expect(() => fieldAddressToString({ shardId: 's space', fieldId: 'f' })).toThrow(/invalid/);
+        expect(() => fieldAddressToString({ shardId: 's', fieldId: 'a:b' })).toThrow(/invalid/);
+    });
+});

package/dist/fields/decoration.d.ts

@@ -0,0 +1,7 @@
+import type { FieldAddress, DecorationHandle } from './types';
+export declare function attachDecoration(addr: FieldAddress, factory: (target: {
+    element: HTMLElement;
+    rect: DOMRect;
+}) => HTMLElement | DecorationHandle): () => void;
+/** Test-only: tear everything down and reset module state. */
+export declare function __resetDecorationLayerForTest(): void;