entangled-worlds-orbiters-shared 5.0.0 → 6.0.0

package/README.md

@@ -6,7 +6,7 @@ A shared library containing core components for 3D world rendering, moons system
 
 - **World System**: Core world rendering with textured spheres, normal materials, GLB models, and cloud shells
 - **Moons System**: Orbital moon generation and management
-- **Loaders**: Texture, GLB, and cubemap loading utilities
+- **Loaders**: Texture and GLB loading utilities
 - **Core Rendering**: Lighting, Fresnel effects, and material utilities
 - **Configuration**: Texture and configuration management system
 
@@ -57,7 +57,6 @@ import * as EntangledWorlds from 'entangled-worlds-orbiters-shared';
 - `moonsGeneration` - Moon generation logic
 
 ### Loaders
-- `cubeMapLoader` - Skybox loading
 - `glbLoader` - GLB loading utilities
 - `bodyTextureLoader` - Texture loading
 
@@ -99,7 +98,7 @@ The capability registry (`createCapabilityRegistry`, `validate` / `assertValid`,
 - `largestFunction`, `shrinkWasm` - The size check and the shrink step
 
 ### Keyboard shortcuts (`entangled-worlds-orbiters-shared/shortcuts`)
-- `ShortcutAction` - One catalogue entry: `id`, `label` (+ `names` by language), `defaultKeys` (by key place, `event.code`), `scope`
+- `ShortcutAction` - One catalogue entry: `id`, `label` (+ `names` by language), `defaultKeys` (named as a US keyboard names them, `event.code`; a press matches by the character it types, by its place only where it types no US character, so keys work on any keyboard), `scope`
 - `matchShortcut(event, bindings)` - Which action a press is, or `null`: modifiers, a field being typed in and surface claims decided in one place
 - Key strings: `Shift+KeyR`, `Mod+KeyZ` (Ctrl or ⌘), `Shift?+KeyQ` (Shift may be held); `parseChord`, `chordsOverlap`
 - `resolveBindings(catalogue, overrides)`, `findClashes` - Defaults plus a person's overrides (`[{ id, keys }]` as their settings store them, `keys: []` unbinds), and the clash check
@@ -150,7 +149,7 @@ Defaults:
 
 Effects:
 - All URLs returned by `config/textureConfig` helpers are absolute.
-- Skybox loader and moons generation resolve relative paths against the configured base.
+- Moons generation resolves relative paths against the configured base.
 - Cloud shell textures passed to `world.makeSphere` are resolved to absolute URLs.
 
 ## Peer Dependencies

package/dist/config/index.d.ts

@@ -1,3 +1,3 @@
-export { loadTextureConfig, getTextureOptions, getTextureChoices, getDefaultTexture, getSkyboxOptions, getDefaultSkybox, getTextureFallbackUrl } from './textureConfig.js';
+export { loadTextureConfig, getTextureOptions, getTextureChoices, getDefaultTexture, getTextureFallbackUrl } from './textureConfig.js';
 export type { TextureConfig, TextureCategory, TextureItem, TextureChoice, TextureConfigMetadata } from './textureConfig.js';
 export { setPublicBase, getPublicBase, resolvePublicUrl } from './env.js';

package/dist/config/index.js

@@ -1,4 +1,4 @@
 // Configuration exports
-export { loadTextureConfig, getTextureOptions, getTextureChoices, getDefaultTexture, getSkyboxOptions, getDefaultSkybox, getTextureFallbackUrl } from './textureConfig.js';
+export { loadTextureConfig, getTextureOptions, getTextureChoices, getDefaultTexture, getTextureFallbackUrl } from './textureConfig.js';
 // runtime base helpers
 export { setPublicBase, getPublicBase, resolvePublicUrl } from './env.js';

package/dist/config/textureConfig.d.ts

@@ -9,12 +9,11 @@ export interface TextureItem {
     fallback?: string;
     tags?: string[];
 }
-/** One catalogue category (clouds, moons, skyboxes, …). */
+/** One catalogue category (clouds, moons, …). */
 export interface TextureCategory {
     category?: string;
     basePath?: string;
     defaultTexture?: string;
-    defaultSkybox?: string;
     items?: TextureItem[];
 }
 /** The texture catalogue as loaded from the config URL. */
@@ -70,7 +69,7 @@ export type TextureChoice = {
 export declare function getTextureChoices(category: string, config?: TextureConfig | null): Promise<TextureChoice[]>;
 /**
  * Get texture options for a specific category (clouds, moons, etc.)
- * @param {string} category - Texture category (clouds, moons, skyboxes)
+ * @param {string} category - Texture category (clouds, moons)
  * @param {TextureConfig} config - Optional pre-loaded config object
  * @returns {Promise<Record<string, string>>} `{ label: url }`, suitable for dropdown option lists
  */
@@ -114,18 +113,6 @@ export declare function getTextureUrl(category: string, textureId: string, confi
  * @returns {Promise<TextureItem[]>} Array of matching texture definitions
  */
 export declare function searchTexturesByTags(category: string, tags: string[], config?: TextureConfig | null): Promise<TextureItem[]>;
-/**
- * Get skybox options formatted for GUI dropdowns
- * @param {TextureConfig} config - Optional pre-loaded config object
- * @returns {Promise<Record<string, string>>} `{ label: id }`
- */
-export declare function getSkyboxOptions(config?: TextureConfig | null): Promise<Record<string, string>>;
-/**
- * Get default skybox ID
- * @param {TextureConfig} config - Optional pre-loaded config object
- * @returns {Promise<string>} Default skybox ID
- */
-export declare function getDefaultSkybox(config?: TextureConfig | null): Promise<string>;
 /**
  * Reload configuration (force refresh)
  * @param {string} configUrl - Override config URL

package/dist/config/textureConfig.js

@@ -117,7 +117,7 @@ export async function getTextureChoices(category, config) {
 }
 /**
  * Get texture options for a specific category (clouds, moons, etc.)
- * @param {string} category - Texture category (clouds, moons, skyboxes)
+ * @param {string} category - Texture category (clouds, moons)
  * @param {TextureConfig} config - Optional pre-loaded config object
  * @returns {Promise<Record<string, string>>} `{ label: url }`, suitable for dropdown option lists
  */
@@ -215,40 +215,6 @@ export async function searchTexturesByTags(category, tags, config) {
     }
     return categoryConfig.items.filter(item => item.tags && tags.some(tag => item.tags.includes(tag)));
 }
-/**
- * Get skybox options formatted for GUI dropdowns
- * @param {TextureConfig} config - Optional pre-loaded config object
- * @returns {Promise<Record<string, string>>} `{ label: id }`
- */
-export async function getSkyboxOptions(config) {
-    const textureConfig = await resolveConfig(config);
-    const skyboxConfig = textureConfig.textures.skyboxes;
-    if (!skyboxConfig) {
-        console.warn('[TextureConfig] Skyboxes category not found');
-        return {};
-    }
-    const options = {};
-    // Reads `items` unguarded, unlike the other readers: a skyboxes category without items throws here.
-    skyboxConfig.items.forEach(item => {
-        const label = item.label || item.id;
-        const id = item.id;
-        options[label] = id;
-    });
-    return options;
-}
-/**
- * Get default skybox ID
- * @param {TextureConfig} config - Optional pre-loaded config object
- * @returns {Promise<string>} Default skybox ID
- */
-export async function getDefaultSkybox(config) {
-    const textureConfig = await resolveConfig(config);
-    const skyboxConfig = textureConfig.textures.skyboxes;
-    if (!skyboxConfig) {
-        return '001'; // fallback
-    }
-    return skyboxConfig.defaultSkybox || '001';
-}
 /**
  * Hardcoded fallback configuration (minimal)
  * Used when remote config loading fails
@@ -275,14 +241,6 @@ function getHardcodedFallback() {
                 items: [
                     { id: "default-moon", filename: "moon-equirectangular.ktx2", label: "Default Moon", tags: ["lunar"] }
                 ]
-            },
-            skyboxes: {
-                category: "environment",
-                basePath: "/skybox",
-                defaultSkybox: "001",
-                items: [
-                    { id: "001", label: "Deep Space", tags: ["space"] }
-                ]
             }
         }
     };

package/dist/loaders/index.d.ts

@@ -1,5 +1,3 @@
-export { loadCubeMap, setBackground, normalizeSkycubeName, buildSkycubefaceKeys } from './cubeMapLoader.js';
 export { loadGLB } from './glbLoader.js';
 export { loadTexture } from './bodyTextureLoader.js';
 export { getKTX2LoaderForRenderer, disposeKTX2LoaderForRenderer } from './ktx2.js';
-export type { SkyboxResource } from './cubeMapLoader.js';

package/dist/loaders/index.js

@@ -1,5 +1,4 @@
 // Loaders exports
-export { loadCubeMap, setBackground, normalizeSkycubeName, buildSkycubefaceKeys } from './cubeMapLoader.js';
 export { loadGLB } from './glbLoader.js';
 export { loadTexture } from './bodyTextureLoader.js';
 export { getKTX2LoaderForRenderer, disposeKTX2LoaderForRenderer } from './ktx2.js';

package/dist/loaders/ktx2.js

@@ -4,12 +4,12 @@ import { KTX2Loader } from 'three/examples/jsm/loaders/KTX2Loader.js';
  *
  * `KTX2Loader.detectSupport(renderer)` binds the loader's Basis transcoder worker pool to ONE WebGL
  * context. A single shared loader therefore only decodes textures for the FIRST renderer it saw —
- * every other view's planets/skyboxes silently fail and render untextured (dark). That breaks any
+ * every other view's planets silently fail and render untextured (dark). That breaks any
  * multi-view page: N orbiters in one realm, or N Entangled World planets shown together.
  *
  * Keying the loader by renderer gives each view its own correctly-bound loader. Single-renderer apps
  * (a single orbiter, today's Entangled World) get exactly ONE entry, so behaviour is byte-identical.
- * (Was: a single `window.__EW_KTX2_LOADER` global shared by bodyTexture/glb/cubeMap loaders.)
+ * (Was: a single `window.__EW_KTX2_LOADER` global shared by the bodyTexture/glb loaders.)
  */
 const loadersByRenderer = new WeakMap();
 function makeLoader(renderer) {

package/dist/shortcuts/chord.d.ts

@@ -18,8 +18,30 @@ export interface ModifierState {
 }
 /** The chord a key string names, or `null` when it names none (an unknown modifier, a doubled one, no key). */
 export declare function parseChord(keys: string): Chord | null;
-/** Whether a press of `code` with these modifiers is this chord. */
-export declare function chordMatches(chord: Chord, code: string, state: ModifierState): boolean;
+/** A press as a chord reads it: the modifiers, the key's place and, when the browser says, the character it typed. */
+export interface ChordPress extends ModifierState {
+    readonly code: string;
+    readonly key?: string;
+}
+/** How a press is this chord: by the character it typed, by the key's place, or not at all. */
+export type ChordMatch = 'character' | 'place' | null;
+/**
+ * How a press is this chord. `character` beats `place`: on a Spanish keyboard Shift+7 types `/`, so it
+ * is the `/` key before it is the `7` key. A press with no `key` (an old caller) matches by place only.
+ */
+export declare function chordMatch(chord: Chord, press: ChordPress): ChordMatch;
+/** Whether a press of `code` with these modifiers (and, when given, the character it typed) is this chord. */
+export declare function chordMatches(chord: Chord, code: string, state: ModifierState & {
+    readonly key?: string;
+}): boolean;
+/**
+ * The key string a typed character names (`/` → `Slash`, `?` → `Shift+Slash`, `q` → `KeyQ`), for
+ * someone setting a key; `null` for a character a US keyboard does not have, or none.
+ */
+export declare function typedKey(key: string | undefined): {
+    readonly code: string;
+    readonly shift?: boolean;
+} | null;
 /** A chord that needs Ctrl or ⌘: a command, never a character typed. */
 export declare function isCommandChord(chord: Chord): boolean;
 /** Whether one press could be both chords — the test for a clash. */

package/dist/shortcuts/chord.js

@@ -1,7 +1,13 @@
 // One key with its modifiers, written as a string: `Shift+KeyR`, `Mod+KeyZ`, `Shift?+Digit1`.
 //
-// The last part is the key's PLACE (`KeyboardEvent.code`), so a French or German keyboard keeps the
-// same layout: the key, not the letter it prints. Before it, the modifiers:
+// The last part names the key the way a US keyboard does (`KeyboardEvent.code`: `KeyQ`, `Slash`,
+// `Digit1`). A press matches it by the CHARACTER it types wherever it types one, so `/` is the key
+// that prints `/` on this person's keyboard (Shift+7 on a Spanish one), and `KeyQ` is the key that
+// prints Q (top left on a French one). Only where the key types no character the US keyboard has
+// (a Greek or Cyrillic letter, ⌥ on a Mac changing it, a dead key, no letter on a letter key) is the
+// key matched by its place.
+// Digits match by character first, then by place: a French keyboard types `&` there.
+// Before the key, the modifiers:
 //
 //   Shift, Alt, Ctrl, Meta   held. One left out must NOT be held.
 //   Mod                      Ctrl or ⌘ (either, or both), the command key of every platform.
@@ -48,18 +54,90 @@ function parse(keys) {
     return { code, ...rules };
 }
 const fits = (rule, down) => rule === 'any' || (rule === 'held') === Boolean(down);
-/** Whether a press of `code` with these modifiers is this chord. */
-export function chordMatches(chord, code, state) {
-    if (chord.code !== code)
-        return false;
-    if (!fits(chord.shift, state.shiftKey) || !fits(chord.alt, state.altKey))
-        return false;
+/**
+ * The punctuation keys a chord may name, and what a US keyboard types there without and with Shift:
+ * what the chord means on every keyboard. With these, Shift is part of the character (`?` is
+ * `Shift+Slash`), so a keyboard that needs Shift, or AltGr, for a `/` still types the `/`.
+ */
+const PUNCTUATION = {
+    Minus: ['-', '_'], Equal: ['=', '+'], BracketLeft: ['[', '{'], BracketRight: [']', '}'], Backslash: ['\\', '|'],
+    Semicolon: [';', ':'], Quote: ["'", '"'], Backquote: ['`', '~'], Comma: [',', '<'], Period: ['.', '>'], Slash: ['/', '?'],
+};
+/** The code a US keyboard types each punctuation character at, and whether it takes Shift. */
+const PUNCTUATION_PLACE = new Map(Object.entries(PUNCTUATION).flatMap(([code, [plain, shifted]]) => [[plain, [code, false]], [shifted, [code, true]]]));
+/** The character a press typed, when it is one a US keyboard has (printable ASCII); else `null`. */
+function typed(key) {
+    return typeof key === 'string' && key.length === 1 && key >= '!' && key <= '~' ? key : null;
+}
+function commandFits(chord, state) {
     if (chord.mod === 'held')
         return Boolean(state.ctrlKey || state.metaKey);
     if (chord.mod === 'any')
         return true;
     return fits(chord.ctrl, state.ctrlKey) && fits(chord.meta, state.metaKey);
 }
+function placeMatch(chord, code, state) {
+    return chord.code === code && fits(chord.shift, state.shiftKey) && fits(chord.alt, state.altKey) && commandFits(chord, state);
+}
+/**
+ * How a press is this chord. `character` beats `place`: on a Spanish keyboard Shift+7 types `/`, so it
+ * is the `/` key before it is the `7` key. A press with no `key` (an old caller) matches by place only.
+ */
+export function chordMatch(chord, press) {
+    const char = typed(press.key);
+    if (char === null)
+        return placeMatch(chord, press.code, press) ? 'place' : null;
+    const punctuation = PUNCTUATION[chord.code];
+    if (punctuation) {
+        // Shift is in the character (a Spanish `/` is Shift+7); with ⌘ some browsers report the key
+        // unshifted, so `⇧⌘,` is also a `,` with Shift held. Alt only when the chord asks for it (AltGr
+        // and ⌥ type characters).
+        const [plain, shifted] = punctuation;
+        const asShifted = char === shifted || (isCommandChord(chord) && char === plain && press.shiftKey);
+        const ok = chord.shift === 'held' ? asShifted : chord.shift === 'any' ? char === plain || asShifted : char === plain;
+        // A command (⇧⌘,) where this keyboard types another character there: the key's place, as menus do.
+        if (!ok)
+            return isCommandChord(chord) && placeMatch(chord, press.code, press) ? 'place' : null;
+        if (chord.alt === 'held' && !press.altKey)
+            return null;
+        // AltGr arrives as Ctrl+Alt on Windows: that Ctrl typed the character, it is no command.
+        const altGr = press.altKey && press.ctrlKey && !press.metaKey;
+        return commandFits(chord, { ctrlKey: press.ctrlKey && !altGr, metaKey: press.metaKey, shiftKey: press.shiftKey, altKey: press.altKey }) ? 'character' : null;
+    }
+    const letter = /^Key([A-Z])$/.exec(chord.code)?.[1];
+    if (letter) {
+        // A key that types no letter (`;` where Q is on a Greek keyboard) is read by its place.
+        if (!/^[a-zA-Z]$/.test(char))
+            return placeMatch(chord, press.code, press) ? 'place' : null;
+        if (char.toUpperCase() !== letter)
+            return null;
+        return fits(chord.shift, press.shiftKey) && fits(chord.alt, press.altKey) && commandFits(chord, press) ? 'character' : null;
+    }
+    const digit = /^Digit(\d)$/.exec(chord.code)?.[1];
+    // A digit typed; where the keyboard types something else there (`&` on a French one), its place.
+    if (digit && char === digit && fits(chord.shift, press.shiftKey) && fits(chord.alt, press.altKey) && commandFits(chord, press))
+        return 'character';
+    return placeMatch(chord, press.code, press) ? 'place' : null;
+}
+/** Whether a press of `code` with these modifiers (and, when given, the character it typed) is this chord. */
+export function chordMatches(chord, code, state) {
+    // Field by field: a browser's KeyboardEvent keeps them on its prototype, where a spread does not reach.
+    const { shiftKey, altKey, ctrlKey, metaKey, key } = state;
+    return chordMatch(chord, { code, key, shiftKey, altKey, ctrlKey, metaKey }) !== null;
+}
+/**
+ * The key string a typed character names (`/` → `Slash`, `?` → `Shift+Slash`, `q` → `KeyQ`), for
+ * someone setting a key; `null` for a character a US keyboard does not have, or none.
+ */
+export function typedKey(key) {
+    const char = typed(key);
+    if (char === null)
+        return null;
+    if (/^[a-zA-Z]$/.test(char))
+        return { code: `Key${char.toUpperCase()}` };
+    const place = PUNCTUATION_PLACE.get(char);
+    return place ? { code: place[0], shift: place[1] } : null;
+}
 /** A chord that needs Ctrl or ⌘: a command, never a character typed. */
 export function isCommandChord(chord) {
     return chord.mod === 'held' || chord.ctrl === 'held' || chord.meta === 'held';

package/dist/shortcuts/format.d.ts

@@ -4,8 +4,8 @@ export type ShortcutPlatform = 'apple' | 'other';
 export declare function shortcutPlatform(): ShortcutPlatform;
 /**
  * The character a key place prints on this person's keyboard, when the browser can say
- * (`navigator.keyboard.getLayoutMap()`, Chromium only); a key place it does not know is shown from
- * its name.
+ * (`navigator.keyboard.getLayoutMap()`, Chromium only). Only keys matched by their place use it:
+ * a letter, digit or punctuation key matches the character it names, so it shows that character.
  */
 export type KeyLayout = ReadonlyMap<string, string>;
 /** What a key place is called on a keyboard: `KeyQ` → `Q`, `Digit1` → `1`, `Numpad4` → `Num 4`. */
@@ -20,11 +20,14 @@ export declare function chordParts(keys: string, platform?: ShortcutPlatform, la
 export declare function formatChord(keys: string, platform?: ShortcutPlatform, layout?: KeyLayout): string;
 /**
  * The key string a press makes, for someone setting a key: exactly the modifiers held, the command
- * key of their platform written `Mod` (⌘ on Apple, Ctrl elsewhere) so the key works on both. `null`
- * while only modifiers are down, or for a press with no key place.
+ * key of their platform written `Mod` (⌘ on Apple, Ctrl elsewhere) so the key works on both. A letter
+ * or punctuation character typed is written as the key that types it on a US keyboard (`/` is
+ * `Slash` whichever keys typed it), the way the matcher reads it back. `null` while only modifiers
+ * are down, or for a press with no key place.
  */
 export declare function chordFromEvent(event: {
     code: string;
+    key?: string;
     shiftKey: boolean;
     altKey: boolean;
     ctrlKey: boolean;

package/dist/shortcuts/format.js

@@ -1,6 +1,6 @@
 // A key string for people: how a chord is shown (`⌘⇧Z`, `Ctrl+Shift+Z`, `Q`), and the key string a
 // press makes when someone sets a key ("press a key to change").
-import { isModifierCode, parseChord } from './chord.js';
+import { isModifierCode, parseChord, typedKey } from './chord.js';
 /** The platform of this browser, by its own report; `other` outside a browser. */
 export function shortcutPlatform() {
     const nav = globalThis.navigator;
@@ -18,7 +18,8 @@ const NAMED = {
 };
 /** What a key place is called on a keyboard: `KeyQ` → `Q`, `Digit1` → `1`, `Numpad4` → `Num 4`. */
 export function keyLabel(code, layout) {
-    const printed = layout?.get(code);
+    const byCharacter = /^(Key[A-Z]|Digit\d)$/.test(code) || typedKey(NAMED[code])?.code === code;
+    const printed = byCharacter ? undefined : layout?.get(code);
     if (printed && printed.trim())
         return printed.length === 1 ? printed.toUpperCase() : printed;
     if (/^Key[A-Z]$/.test(code))
@@ -29,6 +30,11 @@ export function keyLabel(code, layout) {
         return `Num ${code.slice(6)}`;
     return NAMED[code] ?? code;
 }
+/** What a US keyboard types with Shift at each punctuation key. */
+const SHIFTED = {
+    Minus: '_', Equal: '+', BracketLeft: '{', BracketRight: '}', Backslash: '|', Semicolon: ':', Quote: '"',
+    Backquote: '~', Comma: '<', Period: '>', Slash: '?',
+};
 const SYMBOLS = { ctrl: '⌃', alt: '⌥', shift: '⇧', meta: '⌘' };
 const WORDS = { ctrl: 'Ctrl', alt: 'Alt', shift: 'Shift', meta: 'Meta' };
 /**
@@ -55,12 +61,16 @@ export function chordParts(keys, platform = shortcutPlatform(), layout) {
         parts.push(names.ctrl);
     if (held(chord.alt))
         parts.push(platform === 'apple' ? names.alt : 'Alt');
-    if (held(chord.shift))
+    // A punctuation key is the character it types, Shift included: `Shift+Slash` is `?`.
+    // A command (⇧⌘,) is shown as written: its Shift is a key to press, not part of a character.
+    const punctuation = !ctrl && !meta && typedKey(NAMED[chord.code])?.code === chord.code ? SHIFTED[chord.code] : undefined;
+    if (held(chord.shift) && !punctuation)
         parts.push(names.shift);
     if (meta)
         parts.push(names.meta);
-    // The help key is `?` wherever it lets Shift be held (its place is `/`): show what people press.
-    parts.push(chord.code === 'Slash' && chord.shift === 'any' && !layout ? '?' : keyLabel(chord.code, layout));
+    // The help key is `?` wherever it lets Shift be held (`/` or `?`): show what people press.
+    const shifted = punctuation && (held(chord.shift) || (chord.code === 'Slash' && chord.shift === 'any'));
+    parts.push(shifted ? punctuation : keyLabel(chord.code, layout));
     return parts;
 }
 /** One line for a chord: `⌘⇧Z` on Apple keyboards, `Ctrl+Shift+Z` elsewhere. */
@@ -74,28 +84,44 @@ export function formatChord(keys, platform = shortcutPlatform(), layout) {
 }
 /**
  * The key string a press makes, for someone setting a key: exactly the modifiers held, the command
- * key of their platform written `Mod` (⌘ on Apple, Ctrl elsewhere) so the key works on both. `null`
- * while only modifiers are down, or for a press with no key place.
+ * key of their platform written `Mod` (⌘ on Apple, Ctrl elsewhere) so the key works on both. A letter
+ * or punctuation character typed is written as the key that types it on a US keyboard (`/` is
+ * `Slash` whichever keys typed it), the way the matcher reads it back. `null` while only modifiers
+ * are down, or for a press with no key place.
  */
 export function chordFromEvent(event, platform = shortcutPlatform()) {
     if (!event.code || isModifierCode(event.code))
         return null;
+    const typed = typedKey(event.key);
+    const punctuation = typed?.shift !== undefined;
+    // A punctuation character carries its own Shift, and the AltGr or ⌥ that typed it is no modifier.
+    const altGr = punctuation && event.altKey && event.ctrlKey && !event.metaKey;
+    // Field by field: a browser's KeyboardEvent keeps them on its prototype, where a spread does not reach.
+    const press = punctuation
+        ? {
+            // With ⌘ or Ctrl some browsers report the key unshifted: the Shift held is then part of the chord.
+            shiftKey: Boolean(typed.shift) || (event.shiftKey && !altGr && (event.ctrlKey || event.metaKey)),
+            altKey: false,
+            ctrlKey: altGr ? false : event.ctrlKey,
+            metaKey: event.metaKey,
+        }
+        : event;
     const parts = [];
     // ⌘ (Ctrl elsewhere) is written Mod so the key works on both — unless Ctrl and ⌘ are both held,
     // which Mod cannot say: then both by name.
-    if (event.ctrlKey && event.metaKey)
+    if (press.ctrlKey && press.metaKey)
         parts.push('Ctrl', 'Meta');
-    else if (platform === 'apple' ? event.metaKey : event.ctrlKey)
+    else if (platform === 'apple' ? press.metaKey : press.ctrlKey)
         parts.push('Mod');
-    else if (event.ctrlKey)
+    else if (press.ctrlKey)
         parts.push('Ctrl');
-    else if (event.metaKey)
+    else if (press.metaKey)
         parts.push('Meta');
-    if (event.altKey)
+    if (press.altKey)
         parts.push('Alt');
-    if (event.shiftKey)
+    if (press.shiftKey)
         parts.push('Shift');
-    parts.push(event.code);
+    parts.push(typed?.code ?? event.code);
     const keys = parts.join('+');
     return parseChord(keys) ? keys : null;
 }

package/dist/shortcuts/index.d.ts

@@ -1,4 +1,4 @@
-export { parseChord, parseKeys, keysOverlap, chordMatches, chordsOverlap, isCommandChord, type Chord, type ModifierRule, type ModifierState, } from './chord.js';
+export { parseChord, parseKeys, keysOverlap, chordMatch, chordMatches, chordsOverlap, typedKey, isCommandChord, type Chord, type ModifierRule, type ModifierState, type ChordMatch, type ChordPress, } from './chord.js';
 export { matchShortcut, createShortcutMatcher, SEQUENCE_WAIT_MS, resolveBindings, findClashes, claimKeys, isKeyClaimed, isTypingTarget, type ShortcutAction, type ShortcutNames, type ShortcutBindings, type ShortcutOverrides, type ShortcutEvent, } from './match.js';
 export { shortcutPlatform, keyLabel, chordParts, formatChord, chordFromEvent, mergedKeyParts, recordedKeys, type ShortcutPlatform, type KeyLayout, } from './format.js';
 export { EMPTY_CATALOGUE, parseCatalogue, localName, localAppName, localPartName, shortcutApps, sectionActions, findSection, type ShortcutCatalogue, type ShortcutSection, type ShortcutNamed, type ShortcutSheetColumn, type ShortcutSheetRow, } from './catalogue.js';

package/dist/shortcuts/index.js

@@ -1,8 +1,9 @@
 // Keyboard shortcuts, one system for every app: the reader of the shortcut catalogue (every app's
 // actions and default keys, served by the backend) and of a person's own keys, and one matcher that
-// says which action a key press is. Keys are named by their place on the keyboard
-// (`KeyboardEvent.code`). Framework-free: no React, no DOM beyond reading a key event.
-export { parseChord, parseKeys, keysOverlap, chordMatches, chordsOverlap, isCommandChord, } from './chord.js';
+// says which action a key press is. Keys are named as a US keyboard names them
+// (`KeyboardEvent.code`) and matched by the character a press types, so they work on any keyboard.
+// Framework-free: no React, no DOM beyond reading a key event.
+export { parseChord, parseKeys, keysOverlap, chordMatch, chordMatches, chordsOverlap, typedKey, isCommandChord, } from './chord.js';
 export { matchShortcut, createShortcutMatcher, SEQUENCE_WAIT_MS, resolveBindings, findClashes, claimKeys, isKeyClaimed, isTypingTarget, } from './match.js';
 export { shortcutPlatform, keyLabel, chordParts, formatChord, chordFromEvent, mergedKeyParts, recordedKeys, } from './format.js';
 export { EMPTY_CATALOGUE, parseCatalogue, localName, localAppName, localPartName, shortcutApps, sectionActions, findSection, } from './catalogue.js';

package/dist/shortcuts/match.d.ts

@@ -58,7 +58,9 @@ export declare function isKeyClaimed(event: Pick<ShortcutEvent, 'key' | 'metaKey
 export declare function isTypingTarget(target: unknown): boolean;
 /**
  * The action this press is, or `null`. Not one while the person is typing in a field, nor a key a
- * surface holds; a widget that reads characters keeps its characters but not the ⌘ commands.
+ * surface holds; a widget that reads characters keeps its characters but not the ⌘ commands. A key
+ * that matches by the character typed wins over one that only matches by the key's place, whatever
+ * their order (Shift+7 types `/` on a Spanish keyboard: the `/` action, not the `7` one).
  */
 export declare function matchShortcut(event: ShortcutEvent, bindings: ShortcutBindings): string | null;
 /** How long the second key of a sequence (`G`, then `H`) may follow the first. */

package/dist/shortcuts/match.js

@@ -1,7 +1,7 @@
 // Which action a key press is. Each app keeps what its actions DO; this only answers which one a
 // press names, so every app reads keys the same way: the modifiers, a field being typed in, and a
 // surface that holds letters of its own are decided here, once.
-import { chordMatches, isCommandChord, isModifierCode, keysOverlap, parseChord, parseKeys } from './chord.js';
+import { chordMatch, chordMatches, isCommandChord, isModifierCode, keysOverlap, parseChord, parseKeys } from './chord.js';
 /**
  * Every action's keys: its defaults, or the person's override (unknown actions and keys that name no
  * chord are dropped). Catalogue order is kept, so the earlier catalogue wins where two match one press.
@@ -81,23 +81,29 @@ function readsCharacters(target) {
 }
 /**
  * The action this press is, or `null`. Not one while the person is typing in a field, nor a key a
- * surface holds; a widget that reads characters keeps its characters but not the ⌘ commands.
+ * surface holds; a widget that reads characters keeps its characters but not the ⌘ commands. A key
+ * that matches by the character typed wins over one that only matches by the key's place, whatever
+ * their order (Shift+7 types `/` on a Spanish keyboard: the `/` action, not the `7` one).
  */
 export function matchShortcut(event, bindings) {
     if (!event.code || isTypingTarget(event.target) || isKeyClaimed(event))
         return null;
     const characters = readsCharacters(event.target);
+    let byPlace = null;
     for (const [actionId, keys] of bindings) {
         for (const key of keys) {
             const chord = parseChord(key);
-            if (!chord || !chordMatches(chord, event.code, event))
+            const how = chord && chordMatch(chord, event);
+            if (!chord || !how)
                 continue;
-            if (characters && !isCommandChord(chord))
-                return null;
-            return actionId;
+            if (how === 'character')
+                return characters && !isCommandChord(chord) ? null : actionId;
+            byPlace ??= { id: actionId, command: isCommandChord(chord) };
         }
     }
-    return null;
+    if (!byPlace || (characters && !byPlace.command))
+        return null;
+    return byPlace.id;
 }
 // ---------------------------------------------------------------------------------------------
 // Sequences
@@ -137,7 +143,7 @@ export function createShortcutMatcher(waitMs = SEQUENCE_WAIT_MS, now = Date.now)
                     return id;
         }
         if (known.some(([, [one]]) => chordMatches(one, event.code, event))) {
-            first = { code: event.code, shiftKey: event.shiftKey, altKey: event.altKey, ctrlKey: event.ctrlKey, metaKey: event.metaKey, at: now() };
+            first = { code: event.code, key: event.key, shiftKey: event.shiftKey, altKey: event.altKey, ctrlKey: event.ctrlKey, metaKey: event.metaKey, at: now() };
             return null;
         }
         return matchShortcut(event, bindings);

package/dist/sky/geometry.d.ts

@@ -0,0 +1,31 @@
+import * as THREE from 'three';
+import type { WorldSky } from './worldSkyFile.js';
+/** The band's frame: `basis` maps band space (x toward the core, y the band's pole) to the scene. */
+export interface BandFrame {
+    basis: THREE.Matrix4;
+    core: THREE.Vector3;
+}
+/** An equatorial direction in the scene frame (y = celestial north). */
+export declare function equatorial(raDeg: number, decDeg: number, out?: THREE.Vector3): THREE.Vector3;
+/** A seeded band, tilted `tiltDeg` from the equator, its core at a seeded longitude. */
+export declare function seededBandFrame(seed: number, tiltDeg: number): BandFrame;
+/**
+ * The Milky Way: the galactic plane (J2000 north pole and centre). From every catalogued host it
+ * is the same plane to well under a degree, so it holds for every world sky.
+ */
+export declare function galacticBandFrame(): BandFrame;
+/**
+ * The star buffer, exactly `count` stars (the device's star budget). A world sky first: its
+ * catalogue stars copied as they are (brightest first, so a small budget keeps the brightest), then
+ * its stand-ins, then seeded faint fill; a seeded sky is `count` seeded stars. Stars gather into the
+ * band by `band`.
+ */
+export declare function buildStarGeometry(opts: {
+    seed: number;
+    count: number;
+    band: number;
+    frame: BandFrame;
+    world?: WorldSky | null;
+}): THREE.BufferGeometry;
+/** The constellation figures of a world sky, straight from the file. */
+export declare function buildLineGeometry(world: WorldSky): THREE.BufferGeometry;