sh3-core 0.22.2 → 0.23.2

package/dist/layout/slotHostPool.test.js

@@ -1,7 +1,7 @@
 import { describe, it, expect, beforeEach, vi } from 'vitest';
 import { tick } from 'svelte';
 import { resetFramework } from '../__test__/reset';
-import { acquireSlotHost, releaseSlotHost } from './slotHostPool.svelte';
+import { acquireSlotHost, releaseSlotHost, flushPendingDestroys } from './slotHostPool.svelte';
 import { registerView } from '../shards/registry';
 import SlotContainer from './SlotContainer.svelte';
 import { renderWithShell } from '../__test__/render';
@@ -102,6 +102,50 @@ describe('slotHostPool — D.5 root swap preserves app slots', () => {
         expect(teardown).not.toHaveBeenCalled();
     });
 });
+// ─── D.9 ─────────────────────────────────────────────────────────────────────
+describe('slotHostPool — D.9 flushPendingDestroys synchronously unmounts', () => {
+    beforeEach(resetFramework);
+    it('synchronously unmounts pooled hosts whose refcount has reached 0', async () => {
+        const teardown = vi.fn();
+        registerView('flush:view', { mount: () => ({ unmount: teardown }) });
+        // Acquire a slot host, then drop refcount to 0 — this enters pendingDestroy
+        // but does NOT unmount until the next microtask (existing behavior).
+        acquireSlotHost('flush-slot', 'flush:view', 'Flush View');
+        // The view-factory mount is itself deferred to a microtask; let it run
+        // so the pool entry has a real `handle` to unmount.
+        await Promise.resolve();
+        releaseSlotHost('flush-slot');
+        // The destroy microtask has NOT yet run, so teardown has not been called.
+        expect(teardown).not.toHaveBeenCalled();
+        // flushPendingDestroys runs the destroy body now, synchronously.
+        flushPendingDestroys();
+        expect(teardown).toHaveBeenCalledTimes(1);
+    });
+    it('does not unmount entries whose refcount is still > 0', async () => {
+        const teardown = vi.fn();
+        registerView('keep:view', { mount: () => ({ unmount: teardown }) });
+        acquireSlotHost('keep-slot', 'keep:view', 'Keep View');
+        await Promise.resolve();
+        // Refcount is 1, never released.
+        flushPendingDestroys();
+        expect(teardown).not.toHaveBeenCalled();
+        // Cleanup
+        releaseSlotHost('keep-slot');
+    });
+    it('clears pendingDestroy so the queued microtask is a no-op', async () => {
+        const teardown = vi.fn();
+        registerView('once:view', { mount: () => ({ unmount: teardown }) });
+        acquireSlotHost('once-slot', 'once:view', 'Once View');
+        await Promise.resolve();
+        releaseSlotHost('once-slot');
+        flushPendingDestroys();
+        expect(teardown).toHaveBeenCalledTimes(1);
+        // The previously-queued microtask should now find pendingDestroy empty
+        // for this slot and do nothing. teardown stays at 1.
+        await Promise.resolve();
+        expect(teardown).toHaveBeenCalledTimes(1);
+    });
+});
 // ─── D.6 ─────────────────────────────────────────────────────────────────────
 describe('slotHostPool — D.6 data-sh3-view attribute', () => {
     beforeEach(resetFramework);

package/dist/layouts-shard/layoutsShard.svelte.js

@@ -135,6 +135,7 @@ export const layoutsShard = {
         id: '__layouts__',
         label: 'Saved Layouts',
         version: VERSION,
+        kind: 'system',
         views: [],
     },
     register(ctx) {

package/dist/overlays/OverlayRoots.svelte

@@ -14,6 +14,7 @@
    * they portal in.
    */
 
+  import { untrack } from 'svelte';
   import DragPreview from '../layout/DragPreview.svelte';
   import FloatLayer from './FloatLayer.svelte';
   import { registerLayerRoot, unregisterLayerRoot } from './roots';
@@ -47,12 +48,22 @@
     };
   });
 
+  // Re-bind only when the active LayoutTree itself changes (app/preset
+  // switch). bindFloatStore iterates `floats` to clamp persisted entries,
+  // which would otherwise subscribe this effect to every push/splice from
+  // floatManager — and bindFloatStore unconditionally calls
+  // compactRootStore.reset() at the end, so a re-fire on push wipes the
+  // auto-focus that openFloat() set milliseconds earlier (compact-body
+  // would stay on docked after the first ²-press; see float-compact-bind
+  // regression test).
   $effect(() => {
     const tree = layoutStore.tree;
-    bindFloatStore(tree.floats, () => ({
-      w: window.innerWidth,
-      h: window.innerHeight,
-    }));
+    untrack(() => {
+      bindFloatStore(tree.floats, () => ({
+        w: window.innerWidth,
+        h: window.innerHeight,
+      }));
+    });
     return () => unbindFloatStore();
   });
 </script>

package/dist/overlays/__test__/OverlayBindHarness.svelte

@@ -0,0 +1,20 @@
+<script lang="ts">
+  /*
+   * Test harness — mirrors the $effect block in OverlayRoots.svelte that
+   * binds the float manager to the active LayoutTree's floats array.
+   * Keeps the `untrack` shape so the harness validates the production
+   * fix: the bind should NOT re-fire on float push/splice (which would
+   * trip compactRootStore.reset() and wipe auto-focus from openFloat).
+   */
+  import { untrack } from 'svelte';
+  import { layoutStore } from '../../layout/store.svelte';
+  import { bindFloatStore, unbindFloatStore } from '../float';
+
+  $effect(() => {
+    const tree = layoutStore.tree;
+    untrack(() => {
+      bindFloatStore(tree.floats, () => ({ w: 360, h: 740 }));
+    });
+    return () => unbindFloatStore();
+  });
+</script>

package/dist/overlays/__test__/OverlayBindHarness.svelte.d.ts

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

package/dist/overlays/float-compact-bind.svelte.test.d.ts

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

package/dist/overlays/float-compact-bind.svelte.test.js

@@ -0,0 +1,51 @@
+/*
+ * Regression: in compact mode, floatManager.open() must auto-switch the
+ * compact body to the new float. The setRoot call inside openFloat is
+ * correct, but a reactive $effect that re-binds the float store on every
+ * iteration of `tree.floats` re-runs the moment the array is mutated,
+ * and bindFloatStore unconditionally calls compactRootStore.reset() —
+ * wiping the auto-focus that openFloat just set.
+ *
+ * This test mounts a tiny wrapper that mirrors the OverlayRoots $effect
+ * (read layoutStore.tree, call bindFloatStore on every run) and asserts
+ * compactRootStore is still pointing at the new float after open().
+ */
+import { describe, it, expect, beforeEach, afterEach } from 'vitest';
+import { mount, unmount, flushSync } from 'svelte';
+import { floatManager, unbindFloatStore, __resetFloatManagerForTest, } from './float';
+import { compactRootStore, __resetCompactRootStoreForTest, } from '../layout/compact/rootStore.svelte';
+import { __resetLayoutStoreForTest } from '../layout/store.svelte';
+import { viewportStore } from '../viewport/store.svelte';
+import OverlayBindHarness from './__test__/OverlayBindHarness.svelte';
+describe('floatManager.open in compact — preserves setRoot under reactive bind', () => {
+    let mounted = null;
+    let host = null;
+    beforeEach(() => {
+        __resetFloatManagerForTest();
+        __resetCompactRootStoreForTest();
+        __resetLayoutStoreForTest();
+        viewportStore.override('compact');
+    });
+    afterEach(() => {
+        if (mounted) {
+            unmount(mounted);
+            mounted = null;
+        }
+        if (host) {
+            host.remove();
+            host = null;
+        }
+        viewportStore.override(null);
+        unbindFloatStore();
+    });
+    it('opens a float and the compact body root points to it after the bind effect settles', () => {
+        host = document.createElement('div');
+        document.body.appendChild(host);
+        mounted = mount(OverlayBindHarness, { target: host });
+        flushSync();
+        const id = floatManager.open('test:view', { title: 'Notes' });
+        // Allow any reactive re-bind to run.
+        flushSync();
+        expect(compactRootStore.current).toEqual({ kind: 'float', floatId: id });
+    });
+});

package/dist/overlays/modal.js

@@ -96,6 +96,7 @@ function removeEscapeListenerIfIdle() {
     document.removeEventListener('keydown', onDocumentKeydown, true);
 }
 function removeEntry(entry) {
+    var _a;
     const idx = stack.indexOf(entry);
     if (idx < 0)
         return; // already closed — idempotent
@@ -104,6 +105,7 @@ function removeEntry(entry) {
     entry.host.remove();
     syncBackdrop();
     removeEscapeListenerIfIdle();
+    (_a = entry.onClose) === null || _a === void 0 ? void 0 : _a.call(entry);
 }
 function openModal(Content, props, options) {
     const root = getLayerRoot('modal');
@@ -138,6 +140,7 @@ function openModal(Content, props, options) {
     entry.host = host;
     entry.frame = frame;
     entry.handle = handle;
+    entry.onClose = options === null || options === void 0 ? void 0 : options.onClose;
     stack.push(entry);
     syncBackdrop();
     ensureEscapeListener();

package/dist/overlays/modal.test.js

@@ -88,6 +88,51 @@ describe('modal — back-cascade integration', () => {
         expect(layerRoot.querySelectorAll('.sh3-modal-host').length).toBe(0);
     });
 });
+describe('modal — onClose callback', () => {
+    let layerRoot;
+    beforeEach(() => {
+        layerRoot = makeLayerRoot();
+    });
+    afterEach(() => {
+        modalManager.closeAll();
+        teardownLayerRoot(layerRoot);
+    });
+    it('fires onClose when handle.close() is called', async () => {
+        let calls = 0;
+        const handle = modalManager.open(DummyFrame, {}, { onClose: () => calls++ });
+        await tick();
+        handle.close();
+        await tick();
+        expect(calls).toBe(1);
+    });
+    it('fires onClose on backdrop dismissal', async () => {
+        let calls = 0;
+        modalManager.open(DummyFrame, {}, { dismissOnBackdrop: true, onClose: () => calls++ });
+        await tick();
+        const frame = layerRoot.querySelector('.modal-frame');
+        frame.dispatchEvent(new MouseEvent('click', { bubbles: true }));
+        await tick();
+        expect(calls).toBe(1);
+    });
+    it('fires onClose on closeAll', async () => {
+        let calls = 0;
+        modalManager.open(DummyFrame, {}, { onClose: () => calls++ });
+        modalManager.open(DummyFrame, {}, { onClose: () => calls++ });
+        await tick();
+        modalManager.closeAll();
+        await tick();
+        expect(calls).toBe(2);
+    });
+    it('does not fire onClose twice when close() is called repeatedly (idempotent)', async () => {
+        let calls = 0;
+        const handle = modalManager.open(DummyFrame, {}, { onClose: () => calls++ });
+        await tick();
+        handle.close();
+        handle.close();
+        await tick();
+        expect(calls).toBe(1);
+    });
+});
 describe('modal — overlay host marker', () => {
     let layerRoot;
     beforeEach(() => {

package/dist/overlays/types.d.ts

@@ -53,4 +53,13 @@ export interface ModalOptions {
      * palette on touch-only devices).
      */
     initialFocus?: boolean;
+    /**
+     * Invoked after the modal has been torn down — from any dismissal
+     * path (handle.close(), Escape, backdrop click, closeAll). Use this
+     * to reset caller-side "is open" state instead of wrapping
+     * handle.close after open() returns: by then the manager has already
+     * passed handle.close by reference to ModalFrame and onBackdropClick,
+     * so post-hoc wraps would be bypassed by every real dismissal.
+     */
+    onClose?: () => void;
 }

package/dist/primitives/widgets/Field.svelte

@@ -1,6 +1,7 @@
 <script lang="ts">
   import type { Snippet } from 'svelte';
   import type { LiveInputEvents } from './_contract';
+  import { selectOnPointerDown, selectOnFocusEvent } from './_selectOnFocus';
 
   let {
     value = $bindable(''),
@@ -16,6 +17,7 @@
     size = 'md',
     required = false,
     autocomplete,
+    selectOnFocus = false,
     oninput,
     onchange,
   }: {
@@ -32,6 +34,7 @@
     size?: 'sm' | 'md';
     required?: boolean;
     autocomplete?: AutoFill;
+    selectOnFocus?: boolean;
   } & LiveInputEvents<string> = $props();
 
   const showError = $derived(invalid && !!error);
@@ -53,6 +56,8 @@
       bind:value
       oninput={() => oninput?.(value)}
       onblur={() => onchange?.(value)}
+      onpointerdown={selectOnFocus ? selectOnPointerDown : undefined}
+      onfocus={selectOnFocus ? selectOnFocusEvent : undefined}
     />
     {#if suffix}<span class="sh3-field__affix">{@render suffix()}</span>{/if}
   </span>

package/dist/primitives/widgets/Field.svelte.d.ts

@@ -14,6 +14,7 @@ type $$ComponentProps = {
     size?: 'sm' | 'md';
     required?: boolean;
     autocomplete?: AutoFill;
+    selectOnFocus?: boolean;
 } & LiveInputEvents<string>;
 declare const Field: import("svelte").Component<$$ComponentProps, {}, "value">;
 type Field = ReturnType<typeof Field>;

package/dist/primitives/widgets/Field.svelte.test.js

@@ -31,3 +31,19 @@ describe('Field event contract', () => {
         expect(getByText('Required')).toBeInTheDocument();
     });
 });
+describe('Field selectOnFocus opt-in', () => {
+    it('does not select on focus by default', async () => {
+        const { container } = render(Field, { props: { value: 'hello' } });
+        const input = container.querySelector('input');
+        const spy = vi.spyOn(input, 'select');
+        await fireEvent.focus(input);
+        expect(spy).not.toHaveBeenCalled();
+    });
+    it('selects on focus when selectOnFocus is true', async () => {
+        const { container } = render(Field, { props: { value: 'hello', selectOnFocus: true } });
+        const input = container.querySelector('input');
+        const spy = vi.spyOn(input, 'select');
+        await fireEvent.focus(input);
+        expect(spy).toHaveBeenCalledTimes(1);
+    });
+});

package/dist/primitives/widgets/NumberInput.svelte

@@ -2,6 +2,7 @@
   import type { Snippet } from 'svelte';
   import type { LiveInputEvents } from './_contract';
   import { clamp, applyStep } from './NumberInput';
+  import { selectOnPointerDown, selectOnFocusEvent } from './_selectOnFocus';
 
   let {
     value = $bindable(0),
@@ -15,6 +16,8 @@
     disabled = false,
     invalid = false,
     size = 'md',
+    steppers = false,
+    selectOnFocus = false,
     oninput,
     onchange,
   }: {
@@ -29,6 +32,8 @@
     disabled?: boolean;
     invalid?: boolean;
     size?: 'sm' | 'md';
+    steppers?: boolean;
+    selectOnFocus?: boolean;
   } & LiveInputEvents<number> = $props();
 
   function commit(next: number) {
@@ -95,20 +100,24 @@
         commit(value);
         onchange?.(value);
       }}
+      onpointerdown={selectOnFocus ? selectOnPointerDown : undefined}
+      onfocus={selectOnFocus ? selectOnFocusEvent : undefined}
     />
     {#if suffix}<span class="sh3-num__affix">{@render suffix()}</span>{/if}
-    <span class="sh3-num__steppers">
-      <button type="button" {disabled}
-              onpointerdown={() => startHold(1)}
-              onpointerup={stopHold}
-              onpointerleave={stopHold}
-              aria-label="Increase">▲</button>
-      <button type="button" {disabled}
-              onpointerdown={() => startHold(-1)}
-              onpointerup={stopHold}
-              onpointerleave={stopHold}
-              aria-label="Decrease">▼</button>
-    </span>
+    {#if steppers}
+      <span class="sh3-num__steppers">
+        <button type="button" {disabled}
+                onpointerdown={() => startHold(1)}
+                onpointerup={stopHold}
+                onpointerleave={stopHold}
+                aria-label="Increase">▲</button>
+        <button type="button" {disabled}
+                onpointerdown={() => startHold(-1)}
+                onpointerup={stopHold}
+                onpointerleave={stopHold}
+                aria-label="Decrease">▼</button>
+      </span>
+    {/if}
   </span>
 </label>
 

package/dist/primitives/widgets/NumberInput.svelte.d.ts

@@ -12,6 +12,8 @@ type $$ComponentProps = {
     disabled?: boolean;
     invalid?: boolean;
     size?: 'sm' | 'md';
+    steppers?: boolean;
+    selectOnFocus?: boolean;
 } & LiveInputEvents<number>;
 declare const NumberInput: import("svelte").Component<$$ComponentProps, {}, "value">;
 type NumberInput = ReturnType<typeof NumberInput>;

package/dist/primitives/widgets/NumberInput.svelte.test.js

@@ -46,3 +46,29 @@ describe('NumberInput event contract', () => {
         expect(onchange.mock.calls[0][0]).toBeCloseTo(1.23, 5);
     });
 });
+describe('NumberInput steppers opt-in', () => {
+    it('hides ▲▼ buttons by default', () => {
+        const { container } = render(NumberInput, { props: { value: 0 } });
+        expect(container.querySelectorAll('button').length).toBe(0);
+    });
+    it('renders ▲▼ buttons when steppers is true', () => {
+        const { container } = render(NumberInput, { props: { value: 0, steppers: true } });
+        expect(container.querySelectorAll('button').length).toBe(2);
+    });
+});
+describe('NumberInput selectOnFocus opt-in', () => {
+    it('does not select on focus by default', async () => {
+        const { container } = render(NumberInput, { props: { value: 42 } });
+        const input = container.querySelector('input');
+        const spy = vi.spyOn(input, 'select');
+        await fireEvent.focus(input);
+        expect(spy).not.toHaveBeenCalled();
+    });
+    it('selects on focus when selectOnFocus is true', async () => {
+        const { container } = render(NumberInput, { props: { value: 42, selectOnFocus: true } });
+        const input = container.querySelector('input');
+        const spy = vi.spyOn(input, 'select');
+        await fireEvent.focus(input);
+        expect(spy).toHaveBeenCalledTimes(1);
+    });
+});

package/dist/primitives/widgets/ShardPicker.svelte

@@ -0,0 +1,38 @@
+<script lang="ts">
+  import type { CommitOnlyEvents } from './_contract';
+  import PickerList from './PickerList.svelte';
+  import type { PickerItem } from './PickerList';
+  import { listRegisteredShards } from '../../shards/lifecycle.svelte';
+
+  let {
+    value = $bindable<string[]>([]),
+    onchange,
+    disabled = false,
+    size = 'md',
+  }: {
+    value?: string[];
+    disabled?: boolean;
+    size?: 'sm' | 'md';
+  } & CommitOnlyEvents<string[]> = $props();
+
+  const items = $derived<PickerItem[]>(
+    listRegisteredShards()
+      .filter((m) => m.kind === 'service')
+      .map((m) => ({ id: m.id, label: m.label, sublabel: m.id }))
+      .sort((a, b) => a.label.localeCompare(b.label)),
+  );
+
+  function handleChange(next: string[]) {
+    value = next;
+    onchange?.(next);
+  }
+</script>
+
+<PickerList
+  {items}
+  {value}
+  onchange={handleChange}
+  {disabled}
+  {size}
+  emptyText="No service shards installed."
+/>

package/dist/primitives/widgets/ShardPicker.svelte.d.ts

@@ -0,0 +1,9 @@
+import type { CommitOnlyEvents } from './_contract';
+type $$ComponentProps = {
+    value?: string[];
+    disabled?: boolean;
+    size?: 'sm' | 'md';
+} & CommitOnlyEvents<string[]>;
+declare const ShardPicker: import("svelte").Component<$$ComponentProps, {}, "value">;
+type ShardPicker = ReturnType<typeof ShardPicker>;
+export default ShardPicker;

package/dist/primitives/widgets/Textarea.svelte

@@ -1,5 +1,6 @@
 <script lang="ts">
   import type { LiveInputEvents } from './_contract';
+  import { selectOnPointerDown, selectOnFocusEvent } from './_selectOnFocus';
 
   let {
     value = $bindable(''),
@@ -13,6 +14,7 @@
     required = false,
     rows = 3,
     resize = 'vertical',
+    selectOnFocus = false,
     oninput,
     onchange,
   }: {
@@ -27,6 +29,7 @@
     required?: boolean;
     rows?: number;
     resize?: 'none' | 'vertical' | 'both';
+    selectOnFocus?: boolean;
   } & LiveInputEvents<string> = $props();
 
   const showError = $derived(invalid && !!error);
@@ -46,6 +49,8 @@
     bind:value
     oninput={() => oninput?.(value)}
     onblur={() => onchange?.(value)}
+    onpointerdown={selectOnFocus ? selectOnPointerDown : undefined}
+    onfocus={selectOnFocus ? selectOnFocusEvent : undefined}
   ></textarea>
   {#if helperText}<span class="sh3-textarea__helper" class:sh3-textarea__helper--error={showError}>{helperText}</span>{/if}
 </label>

package/dist/primitives/widgets/Textarea.svelte.d.ts

@@ -11,6 +11,7 @@ type $$ComponentProps = {
     required?: boolean;
     rows?: number;
     resize?: 'none' | 'vertical' | 'both';
+    selectOnFocus?: boolean;
 } & LiveInputEvents<string>;
 declare const Textarea: import("svelte").Component<$$ComponentProps, {}, "value">;
 type Textarea = ReturnType<typeof Textarea>;

package/dist/primitives/widgets/Textarea.svelte.test.js

@@ -27,3 +27,19 @@ describe('Textarea event contract', () => {
         expect(ta.style.resize).toBe('none');
     });
 });
+describe('Textarea selectOnFocus opt-in', () => {
+    it('does not select on focus by default', async () => {
+        const { container } = render(Textarea, { props: { value: 'hello' } });
+        const ta = container.querySelector('textarea');
+        const spy = vi.spyOn(ta, 'select');
+        await fireEvent.focus(ta);
+        expect(spy).not.toHaveBeenCalled();
+    });
+    it('selects on focus when selectOnFocus is true', async () => {
+        const { container } = render(Textarea, { props: { value: 'hello', selectOnFocus: true } });
+        const ta = container.querySelector('textarea');
+        const spy = vi.spyOn(ta, 'select');
+        await fireEvent.focus(ta);
+        expect(spy).toHaveBeenCalledTimes(1);
+    });
+});

package/dist/primitives/widgets/_DocumentBrowser.svelte

@@ -26,6 +26,8 @@
     listFolders,
     handle,
     readOnlyShard,
+    initialShardId = null,
+    lockToShard = false,
   }: {
     mode: 'open' | 'save';
     docs: DocEntry[];
@@ -43,6 +45,8 @@
       delete: (shardId: string, path: string) => Promise<void>;
     };
     readOnlyShard?: (shardId: string) => boolean;
+    initialShardId?: string | null;
+    lockToShard?: boolean;
   } = $props();
 
   type Selected =
@@ -50,7 +54,7 @@
     | { kind: 'folder'; fullPath: string; name: string }
     | null;
 
-  let shardId = $state<string | null>(null);
+  let shardId = $state<string | null>(untrack(() => initialShardId));
   let prefix = $state('');
   let selected = $state<Selected>(null);
   let filename = $state(untrack(() => suggestedName));
@@ -76,7 +80,11 @@
   });
 
   const items = $derived(buildTree(docs, folders, shardId, prefix));
-  const crumbs = $derived(breadcrumbSegments(shardId, prefix));
+  const crumbs = $derived(
+    lockToShard
+      ? breadcrumbSegments(shardId, prefix).filter((c) => c.level > 0)
+      : breadcrumbSegments(shardId, prefix),
+  );
 
   $effect(() => {
     items;
@@ -352,7 +360,7 @@
           parts.pop();
           prefix = parts.join('/');
           activeIdx = 0;
-        } else if (shardId) {
+        } else if (shardId && !lockToShard) {
           e.preventDefault();
           shardId = null;
           activeIdx = 0;

package/dist/primitives/widgets/_DocumentBrowser.svelte.d.ts

@@ -18,6 +18,8 @@ type $$ComponentProps = {
         delete: (shardId: string, path: string) => Promise<void>;
     };
     readOnlyShard?: (shardId: string) => boolean;
+    initialShardId?: string | null;
+    lockToShard?: boolean;
 };
 declare const DocumentBrowser: import("svelte").Component<$$ComponentProps, {}, "">;
 type DocumentBrowser = ReturnType<typeof DocumentBrowser>;

package/dist/primitives/widgets/_selectOnFocus.d.ts

@@ -0,0 +1,15 @@
+/**
+ * Shared "select content on focus" opt-in handlers for keystroke widgets
+ * (Field, Textarea, NumberInput).
+ *
+ * Two paths:
+ *  - pointer click on an unfocused input: preventDefault on pointerdown to
+ *    suppress native caret placement, then focus() + select() ourselves.
+ *    Clicking again while already focused falls through to normal caret
+ *    placement, so users can still edit a single character.
+ *  - tab / label click: onfocus selects all.
+ *
+ * Internal — not exported from api.ts.
+ */
+export declare function selectOnPointerDown(e: PointerEvent): void;
+export declare function selectOnFocusEvent(e: FocusEvent): void;

package/dist/primitives/widgets/_selectOnFocus.js

@@ -0,0 +1,24 @@
+/**
+ * Shared "select content on focus" opt-in handlers for keystroke widgets
+ * (Field, Textarea, NumberInput).
+ *
+ * Two paths:
+ *  - pointer click on an unfocused input: preventDefault on pointerdown to
+ *    suppress native caret placement, then focus() + select() ourselves.
+ *    Clicking again while already focused falls through to normal caret
+ *    placement, so users can still edit a single character.
+ *  - tab / label click: onfocus selects all.
+ *
+ * Internal — not exported from api.ts.
+ */
+export function selectOnPointerDown(e) {
+    const el = e.currentTarget;
+    if (document.activeElement !== el) {
+        e.preventDefault();
+        el.focus();
+        el.select();
+    }
+}
+export function selectOnFocusEvent(e) {
+    e.currentTarget.select();
+}

package/dist/projects/scope-gate.d.ts

@@ -0,0 +1,4 @@
+import type { App } from '../apps/types';
+import type { ProjectRecord } from '../projects-shard/projectsApi';
+import type { ShardManifest } from '../shards/types';
+export declare function resolveAllowedShardIds(project: ProjectRecord | null, apps: ReadonlyMap<string, App>, shardManifests: readonly ShardManifest[]): Set<string> | null;