@geastack/core 0.1.33 → 0.1.35

package/index.d.ts

@@ -1,5 +1,12 @@
 /// <reference path="./css.d.ts" />
 
+export type * from './workers'
+export type * from './audio-worklet'
+/** Gea-only hardware output cancellation; call from an AudioWorklet message handler. */
+export declare function flushAudioWorkletOutput(): void
+export type * from './typed-arrays'
+import type { AudioContextOptions, AudioWorklet, MediaStreamAudioSourceNode } from './audio-worklet'
+
 // Opt-in native 64-bit integer. Structurally a `number` (assign/read without
 // casts), but where a binding, parameter, field, or return is annotated `int`,
 // geatsc lowers it to a C++ `long long` and emits exact integer arithmetic
@@ -70,6 +77,7 @@ export interface GeaIntrinsicElements {
   h5: NativeViewProps
   h6: NativeViewProps
   audio: AudioProps
+  video: VideoProps
   button: NativeButtonProps
   img: ImageProps
   input: NativeInputElementProps
@@ -117,9 +125,13 @@ declare global {
   // (`double setTimeout(TimerCallback, double)`), so both the id and the delay
   // are `number`, and the callback takes no arguments (unlike the browser's,
   // which forwards extra `setTimeout` arguments to it).
+  /** @gea-host-no-property-writes */
   function setTimeout(callback: () => void, delayMs: number): number
+  /** @gea-host-no-property-writes */
   function clearTimeout(id: number): void
+  /** @gea-host-no-property-writes */
   function setInterval(callback: () => void, delayMs: number): number
+  /** @gea-host-no-property-writes */
   function clearInterval(id: number): void
 
   /**
@@ -364,6 +376,7 @@ export interface Document {
   querySelector(selector: string): Element | null
   querySelectorAll(selector: string): readonly Element[]
   createElement(tag: 'audio'): HTMLAudioElement
+  createElement(tag: 'video'): HTMLVideoElement
   createElement(tag: 'virtual-list'): VirtualListElement
   createElement(tag: string): Element
   createTextNode(text: string): Node
@@ -596,13 +609,28 @@ export interface AudioProps extends DataAttributes {
   autoplay?: boolean | string | number
   controls?: boolean | string | number
   loop?: boolean | string | number
-  ref?: HTMLAudioElement | null
+  ref?: HTMLAudioElement | (typeof globalThis extends { HTMLAudioElement: { prototype: infer E } } ? E : never) | null
+  autoPlay?: boolean
   children?: any
 }
 
+export interface VideoProps extends DataAttributes {
+  id?: string
+  class?: ClassValue
+  style?: Style
+  autoplay?: boolean
+  muted?: boolean
+  playsinline?: boolean
+  autoPlay?: boolean
+  playsInline?: boolean
+  ref?: HTMLVideoElement | (typeof globalThis extends { HTMLVideoElement: { prototype: infer E } } ? E : never) | null
+}
+
 export type ImageSource = string | ArrayBuffer | Uint8Array | GeaEmbeddedImage
 
 export interface ImageProps extends DataAttributes {
+  alt?: string
+  key?: string | number
   id?: string
   class?: ClassValue
   // Optional: a static template can leave this unset and apply the source
@@ -1300,15 +1328,26 @@ export interface OscillatorNode {
 }
 
 export interface AudioContext {
+  /** Conservative maximum software buffering delay, in seconds. */
+  readonly baseLatency: number
+  /** Device buffering estimate in seconds; zero when unavailable. */
+  readonly outputLatency: number
+  readonly sampleRate: number
+  readonly state: 'running' | 'suspended' | 'closed'
+  readonly audioWorklet: AudioWorklet
   readonly currentTime: number
   readonly destination: AudioDestinationNode
   createOscillator(): OscillatorNode
   createBufferSource(): AudioBufferSourceNode
   decodeAudioData(audioData: ArrayBuffer | Uint8Array | GeaAudioBlob): Promise<AudioBuffer>
+  createMediaStreamSource(stream: MediaStream): MediaStreamAudioSourceNode
+  resume(): Promise<void>
+  suspend(): Promise<void>
+  close(): Promise<void>
 }
 
 export interface AudioContextConstructor {
-  new (): AudioContext
+  new (options?: AudioContextOptions): AudioContext
 }
 
 export declare const audioContext: AudioContext
@@ -1531,6 +1570,7 @@ export interface ButtonProps {
 }
 
 export interface NativeButtonProps extends NativeEventAttributes {
+  disabled?: boolean
   key?: string | number
   class?: ClassValue
   style?: Style
@@ -1653,9 +1693,13 @@ export interface FetchResponse {
   bytes(): Uint8Array
 }
 
+/** @gea-host-no-property-writes */
 export declare function fetchAsync(url: string, init?: FetchRequestInit): number
+/** @gea-host-no-property-writes */
 export declare function fetchReady(id: number): boolean
+/** @gea-host-no-property-writes */
 export declare function fetchResult(id: number): FetchResponse
+/** @gea-host-no-property-writes */
 export declare function fetchRelease(id: number): void
 
 /**
@@ -1692,6 +1736,7 @@ export declare function fetchUploadTotal(id: number): number
 
 declare global {
   function fetch(url: string, init?: FetchRequestInit): FetchResponse
+  /** @gea-host-no-property-writes */
   function fetchAsync(url: string, init?: FetchRequestInit): number
   function fetchUploadFileAsync(
     url: string,
@@ -1705,8 +1750,11 @@ declare global {
   function fetchUploadProgress(id: number): number
   function fetchUploadSent(id: number): number
   function fetchUploadTotal(id: number): number
+  /** @gea-host-no-property-writes */
   function fetchReady(id: number): boolean
+  /** @gea-host-no-property-writes */
   function fetchResult(id: number): FetchResponse
+  /** @gea-host-no-property-writes */
   function fetchRelease(id: number): void
   function atob(data: string): string
   function btoa(data: string | ArrayBuffer | Uint8Array): string
@@ -1727,18 +1775,20 @@ export interface WebSocketErrorEvent {
 }
 
 export interface WebSocketInstance {
+  readonly bufferedAmount: number
   readonly url: string
   readonly readyState: number
   onopen: (() => void) | null
   onmessage: ((event: WebSocketMessageEvent) => void) | null
   onclose: ((event: WebSocketCloseEvent) => void) | null
   onerror: ((event: WebSocketErrorEvent) => void) | null
+  /** @gea-host-no-property-writes */
   send(data: string): void
   close(code?: number, reason?: string): void
 }
 
 export interface WebSocketConstructor {
-  new (url: string): WebSocketInstance
+  new (url: string, protocols?: string | string[]): WebSocketInstance
   readonly CONNECTING: 0
   readonly OPEN: 1
   readonly CLOSING: 2
@@ -1805,7 +1855,7 @@ export declare const http: HttpModule
 
 export interface MediaStreamTrack {
   readonly id: string
-  readonly kind: 'audio'
+  readonly kind: string
   enabled: boolean
   readonly readyState: 'live' | 'ended'
   stop(): void
@@ -1813,12 +1863,19 @@ export interface MediaStreamTrack {
 
 export interface MediaStream {
   readonly id: string
+  readonly active: boolean
   getAudioTracks(): MediaStreamTrack[]
+  getVideoTracks(): MediaStreamTrack[]
   getTracks(): MediaStreamTrack[]
+  getTrackById(id: string): MediaStreamTrack | null
+  addTrack(track: MediaStreamTrack): void
+  removeTrack(track: MediaStreamTrack): void
 }
 
 export interface MediaStreamConstructor {
   new (): MediaStream
+  new (stream: MediaStream): MediaStream
+  new (tracks: MediaStreamTrack[]): MediaStream
 }
 
 export interface MediaStreamConstraints {
@@ -1863,10 +1920,34 @@ export interface MediaRecorderConstructor {
 
 export interface HTMLAudioElement extends Element {
   src: string
+  srcObject: MediaStream | null
+  autoplay: boolean
+  readonly paused: boolean
   currentTime: number
   volume: number
   loop: boolean
-  play(): void
+  play(): Promise<void>
+  pause(): void
+  /** Freeze the current PCM queue endpoint; later RTP silence is excluded. */
+  beginDrain(): void
+  /** Discard queued speech while keeping the live output clock running. */
+  clearBufferedAudio(): void
+  /** Queued PCM has reached the output driver. Hardware DMA drains on capture handoff. */
+  readonly drained: boolean
+  /** RMS of PCM being pulled for playback, normalized to 0–1. */
+  readonly audioLevel: number
+}
+
+export interface HTMLVideoElement extends Element {
+  /** Native HTTP multipart JPEG streaming; decoded on native network/video workers. */
+  src: string
+  srcObject: MediaStream | null
+  autoplay: boolean
+  readonly paused: boolean
+  readonly videoWidth: number
+  readonly videoHeight: number
+  onplaying: (() => void) | null
+  play(): Promise<void>
   pause(): void
 }
 
@@ -1875,6 +1956,13 @@ export interface AudioConstructor {
 }
 
 declare global {
+  interface HTMLAudioElement {
+    beginDrain(): void
+    clearBufferedAudio(): void
+    readonly drained: boolean
+    /** RMS of PCM being pulled for playback, normalized to 0–1. */
+    readonly audioLevel: number
+  }
   interface Blob {
     readonly path: string
   }
@@ -1907,10 +1995,54 @@ export interface RTCSessionDescriptionInit {
   sdp?: string
 }
 
+export interface RTCSessionDescription {
+  readonly type: RTCSessionDescriptionInit['type']
+  readonly sdp: string
+  toJSON(): RTCSessionDescriptionInit
+}
+export interface RTCSessionDescriptionConstructor {
+  new (init: RTCSessionDescriptionInit): RTCSessionDescription
+}
+declare global {
+  const RTCSessionDescription: RTCSessionDescriptionConstructor
+}
+
 export interface RTCIceCandidateInit {
-  candidate: string
+  candidate?: string
   sdpMid?: string | null
   sdpMLineIndex?: number | null
+  usernameFragment?: string | null
+}
+
+export interface RTCLocalIceCandidateInit extends RTCIceCandidateInit {
+  relayProtocol?: 'udp' | 'tcp' | 'tls' | null
+  url?: string | null
+}
+
+export interface RTCIceCandidate {
+  readonly candidate: string
+  readonly sdpMid: string | null
+  readonly sdpMLineIndex: number | null
+  readonly foundation: string | null
+  readonly component: 'rtp' | 'rtcp' | null
+  readonly priority: number | null
+  readonly address: string | null
+  readonly protocol: 'udp' | 'tcp' | null
+  readonly port: number | null
+  readonly type: 'host' | 'srflx' | 'prflx' | 'relay' | null
+  readonly tcpType: 'active' | 'passive' | 'so' | null
+  readonly relatedAddress: string | null
+  readonly relatedPort: number | null
+  readonly usernameFragment: string | null
+  readonly relayProtocol: 'udp' | 'tcp' | 'tls' | null
+  readonly url: string | null
+  toJSON(): RTCIceCandidateInit
+}
+export interface RTCIceCandidateConstructor {
+  new (init?: RTCLocalIceCandidateInit): RTCIceCandidate
+}
+declare global {
+  const RTCIceCandidate: RTCIceCandidateConstructor
 }
 
 export interface RTCIceServer {
@@ -1921,15 +2053,61 @@ export interface RTCIceServer {
 
 export interface RTCConfiguration {
   iceServers?: RTCIceServer[]
+  iceTransportPolicy?: 'all' | 'relay'
 }
 
 export interface RTCPeerConnectionIceEvent {
-  readonly candidate: RTCIceCandidateInit | null
+  readonly candidate: RTCIceCandidate | null
 }
 
 export interface RTCTrackEvent {
   readonly track: MediaStreamTrack
   readonly streams: readonly MediaStream[]
+  readonly receiver: RTCRtpReceiver
+  readonly transceiver: RTCRtpTransceiver
+}
+
+export interface RTCDataChannelInit {
+  ordered?: boolean
+  maxPacketLifeTime?: number
+  maxRetransmits?: number
+  protocol?: string
+  negotiated?: boolean
+  id?: number
+}
+export interface RTCDataChannelMessageEvent { readonly data: string | ArrayBuffer }
+export interface RTCDataChannel {
+  readonly label: string
+  readonly protocol: string
+  readonly ordered: boolean
+  readonly id: number | null
+  readonly maxPacketLifeTime: number | null
+  readonly maxRetransmits: number | null
+  readonly readyState: 'connecting' | 'open' | 'closing' | 'closed'
+  binaryType: 'arraybuffer'
+  readonly bufferedAmount: number
+  bufferedAmountLowThreshold: number
+  onopen: (() => void) | null
+  onclose: (() => void) | null
+  onmessage: ((event: RTCDataChannelMessageEvent) => void) | null
+  onbufferedamountlow: (() => void) | null
+  send(data: string | ArrayBuffer | Uint8Array): void
+  close(): void
+}
+export interface RTCRtpSender {
+  readonly track: MediaStreamTrack | null
+  replaceTrack(track: MediaStreamTrack | null): Promise<void>
+}
+export interface RTCRtpReceiver { readonly track: MediaStreamTrack | null }
+export interface RTCRtpTransceiverInit { direction?: 'sendrecv' | 'sendonly' | 'recvonly' | 'inactive' }
+export interface RTCRtpTransceiver {
+  readonly sender: RTCRtpSender
+  readonly receiver: RTCRtpReceiver
+  readonly mid: string | null
+  direction: 'sendrecv' | 'sendonly' | 'recvonly' | 'inactive'
+  readonly currentDirection: 'sendrecv' | 'sendonly' | 'recvonly' | 'inactive' | null
+  readonly stopped: boolean
+  stop(): void
 }
 
 export interface RTCPeerConnectionInstance {
@@ -1941,7 +2119,19 @@ export interface RTCPeerConnectionInstance {
   onconnectionstatechange: (() => void) | null
   oniceconnectionstatechange: (() => void) | null
 
-  addTrack(track: MediaStreamTrack, stream: MediaStream): void
+  readonly signalingState: 'stable' | 'have-local-offer' | 'have-remote-offer' | 'closed'
+  readonly localDescription: RTCSessionDescription | null
+  readonly remoteDescription: RTCSessionDescription | null
+  onsignalingstatechange: (() => void) | null
+  onnegotiationneeded: (() => void) | null
+  ondatachannel: ((event: { channel: RTCDataChannel }) => void) | null
+  addTrack(track: MediaStreamTrack, stream?: MediaStream): RTCRtpSender
+  removeTrack(sender: RTCRtpSender): void
+  addTransceiver(trackOrKind: MediaStreamTrack | 'audio', init?: RTCRtpTransceiverInit): RTCRtpTransceiver
+  getTransceivers(): RTCRtpTransceiver[]
+  getSenders(): RTCRtpSender[]
+  getReceivers(): RTCRtpReceiver[]
+  createDataChannel(label: string, init?: RTCDataChannelInit): RTCDataChannel
   createOffer(): Promise<RTCSessionDescriptionInit>
   createAnswer(): Promise<RTCSessionDescriptionInit>
   setLocalDescription(desc: RTCSessionDescriptionInit): Promise<void>
@@ -1958,3 +2148,33 @@ declare global {
   const RTCPeerConnection: RTCPeerConnectionConstructor
   function Image(props: ImageProps): GeaJsxElement
 }
+
+
+/** Streaming mono signed PCM16, little endian, carried as base64 text. */
+export interface PcmAudioStream {
+  setInput(stream: MediaStream): void
+  /** Capture and upload on the native socket worker, independently of UI callbacks. */
+  pipeTo(socket: WebSocketInstance, prefix: string, suffix: string): void
+  /** Decode matching PCM packets on the native receive worker; control messages still reach JS. */
+  receiveFrom(socket: WebSocketInstance, prefix: string, suffix: string): void
+  /** Read the next 40ms capture block, or an empty string if not ready. */
+  readBase64(): string
+  writeBase64(data: string): void
+  resetPlayback(interrupted?: boolean): void
+  close(): void
+  readonly queuedMs: number
+  /** Conservative audible duration, excluding mixer and device DMA latency. */
+  readonly playedMs: number
+  readonly drained: boolean
+  readonly audioLevel: number
+  readonly capturePendingMs: number
+  readonly captureDroppedSamples: number
+  readonly capturePackets: number
+}
+export interface PcmAudioStreamConstructor {
+  new (sampleRate: number): PcmAudioStream
+}
+
+declare global {
+  const PcmAudioStream: PcmAudioStreamConstructor
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@geastack/core",
-  "version": "0.1.33",
+  "version": "0.1.35",
   "description": "GeaStack app API, reactivity headers, runtime sources, and type declarations.",
   "license": "Apache-2.0",
   "repository": {
@@ -34,6 +34,9 @@
   "files": [
     "app_frame_perf.cpp",
     "css.d.ts",
+    "workers.d.ts",
+    "audio-worklet.d.ts",
+    "typed-arrays.d.ts",
     "events.cpp",
     "gea_sources.sh",
     "gea_sources.mjs",
@@ -63,7 +66,7 @@
     "@geajs/core": "1.5.1",
     "@geajs/vite-plugin": "1.5.0",
     "@geastack/compiler": "^1.0.20",
-    "@geastack/geatsc-plugin-gea": "^0.1.14",
+    "@geastack/geatsc-plugin-gea": "^0.1.15",
     "opentype.js": "^2.0.0",
     "vite": "^8.0.0"
   }

package/runtime/audio-worklet.ts

@@ -0,0 +1,51 @@
+import type { MessagePort } from '../workers.js'
+
+/** Native implementations of the AudioWorkletGlobalScope's two class APIs.
+ * The module loader supplies these lexical bindings to compiled worklet modules;
+ * applications use the browser globals, without imports or platform branches.
+ */
+
+declare function __geaAudioWorkletProcessorPort(): MessagePort
+declare function __geaFlushAudioWorkletOutput(): void
+
+/** Gea hardware cancellation extension; capture remains active. */
+export function flushAudioWorkletOutput(): void {
+  __geaFlushAudioWorkletOutput()
+}
+
+declare function __geaRegisterAudioWorkletProcessor(
+  name: string,
+  create: () => AudioWorkletProcessor,
+  process: (
+    processor: AudioWorkletProcessor,
+    inputs: Float32Array[][],
+    outputs: Float32Array[][]
+  ) => boolean
+): void
+
+export abstract class AudioWorkletProcessor {
+  readonly port: MessagePort
+
+  constructor() {
+    this.port = __geaAudioWorkletProcessorPort()
+  }
+
+  abstract process(
+    inputs: Float32Array[][],
+    outputs: Float32Array[][],
+    parameters: Record<string, Float32Array>
+  ): boolean
+}
+
+// The native module builder validates the concrete registration constructor.
+// AudioParam descriptors are explicitly unsupported, before code generation.
+export function registerProcessor(
+  name: string,
+  constructor: new () => AudioWorkletProcessor
+): void {
+  __geaRegisterAudioWorkletProcessor(
+    name,
+    () => new constructor(),
+    (processor, inputs, outputs) => processor.process(inputs, outputs, {})
+  )
+}

package/runtime-surface.ts

@@ -1,4 +1,7 @@
 export * from './runtime/compiler'
+export type * from './workers'
+export type * from './audio-worklet'
+export { flushAudioWorkletOutput } from './runtime/audio-worklet'
 export * from './runtime/host'
 export * from './runtime/ble'
 export * from './runtime/images'
@@ -109,6 +112,10 @@ export type {
   GeolocationPosition,
   GeolocationPositionError,
   HTMLAudioElement,
+  PcmAudioStream,
+  PcmAudioStreamConstructor,
+  HTMLVideoElement,
+  VideoProps,
   HttpModule,
   HttpRequestHandler,
   HttpServer,

package/scripts/build-gea-vite-geatsc.mjs

@@ -8,6 +8,7 @@ import { fileURLToPath, pathToFileURL } from 'node:url'
 import { inlineJsonImports, transformGeaEmbeddedCompatSource } from './gea-embedded-compat-transform.mjs'
 import { normalizeEmbeddedJsxOptions, shouldIgnoreCompatStagingDirectory } from './gea-embedded-compat-staging.mjs'
 import { dotEnvDefines, inlineProcessEnv } from './dotenv-defines.mjs'
+import { collectWorkerModuleSources, writeWorkerRegistry, validateWorkletRegistrations } from './gea-worker-modules.mjs'
 import { resolveCompilerRuntimeEntry } from './gea-native-style-plugin.mjs'
 import {
   MODULE_HINT_SCOPE,
@@ -20,6 +21,8 @@ import {
   restoreModuleGraphElAnnotations,
 } from './gea-bundle-type-hints.mjs'
 
+const nativeModules = new Map()
+let nativeModuleSources = new Map()
 const args = process.argv.slice(2)
 const requireFromLib = createRequire(new URL('../package.json', import.meta.url))
 const coreRoot = path.resolve(path.dirname(fileURLToPath(import.meta.url)), '..')
@@ -246,7 +249,11 @@ function copyCompatSourceTree(srcDir, dstDir, envDefines = {}) {
         // (the fully native store/record lowering path). Then bake in .env vars
         // (process.env.<KEY> -> literal) so the module-graph snapshots geatsc
         // compiles carry the value — Vite's `define` only rewrites the bundle.
-        fs.writeFileSync(dst, inlineProcessEnv(transformGeaEmbeddedCompatSource(inlineJsonImports(code, src), src), envDefines))
+        const native = nativeModuleSources.get(src) ?? { code, modules: [] }
+        for (const module of native.modules) {
+          nativeModules.set(`${module.kind}:${module.url}`, { ...module, stagedEntry: path.resolve(path.dirname(dst), path.relative(path.dirname(src), module.entry)) })
+        }
+        fs.writeFileSync(dst, inlineProcessEnv(transformGeaEmbeddedCompatSource(inlineJsonImports(native.code, src), src), envDefines))
       } else {
         fs.copyFileSync(src, dst)
         if (path.extname(entry.name) === '.css') copyCssUrlAssets(src, dst)
@@ -304,7 +311,7 @@ function linkCompatNodeModules(appDir, stagedAppDir, compatSrcDir) {
 // staging its containing directory wholesale (which also brings the css/asset
 // files discoverLocalImport skips).
 function escapedCompatImportDirs(appDir, entry) {
-  const escaped = collectReachableSourceFiles(appDir, entry).filter((file) => path.relative(appDir, file).startsWith('..'))
+  const escaped = [...new Set([...collectReachableSourceFiles(appDir, entry), ...nativeModuleSources.keys()])].filter((file) => path.relative(appDir, file).startsWith('..'))
   const dirs = [...new Set(escaped.map((file) => path.dirname(file)))].sort()
   return dirs.filter((dir, index) => !dirs.slice(0, index).some((outer) => outer !== dir && !path.relative(outer, dir).startsWith('..')))
 }
@@ -4393,6 +4400,8 @@ let stagedEntryFile = null
 let fontSourceDir = appDir
 
 if (geaEmbeddedCompat) {
+  nativeModuleSources = collectWorkerModuleSources(path.resolve(appDir, entry),
+    (file) => collectReachableSourceFiles(path.dirname(file), path.basename(file)))
   const compatSrcDir = path.join(outDir, 'gea-embedded-compat-src')
   fs.rmSync(compatSrcDir, { recursive: true, force: true })
   // Relative imports may escape the app dir (examples/shared components).
@@ -4587,7 +4596,46 @@ if (hasFlag('--gea-ir-backend') || hasFlag('--gea-replace-renderers')) {
 // measurement scripts are always run with this
 // limit; the build has to state the same one, not depend on the caller's
 // NODE_OPTIONS.
-run('node', ['--max-old-space-size=32768', ...geatscArgs])
+// Native interface call graphs can exceed V8's default ~1 MiB stack during
+// closure analysis; keep the compiler stack below the host's 8 MiB limit.
+run('node', ['--stack_size=8192', '--max-old-space-size=32768', ...geatscArgs])
+
+if (nativeModules.size) {
+  const nativeSources = []
+  for (const module of nativeModules.values()) {
+    if (!fs.existsSync(module.stagedEntry)) fail(`missing ${module.kind} module: ${module.entry}`)
+    if (module.kind === 'worklet') {
+      const implementation = path.join(coreRoot, 'runtime/audio-worklet.ts')
+      const bindings = `import { AudioWorkletProcessor, registerProcessor } from ${JSON.stringify(implementation)}\n`
+      const source = fs.readFileSync(module.stagedEntry, 'utf8')
+      fs.writeFileSync(module.stagedEntry, bindings + source)
+      const compilerRequire = createRequire(pathToFileURL(geatscBin))
+      validateWorkletRegistrations(compilerRequire('typescript'), module.stagedEntry, implementation)
+    }
+    const moduleOut = path.join(outDir, `${module.kind}-${module.id}`)
+    const moduleArgs = [
+      geatscBin, 'compile', module.stagedEntry, '--out-dir', moduleOut,
+      '--target', 'cpp', '--plugin', geaPluginSpecifier,
+      '--entry-symbol', module.symbol, '--isolate-symbols', '--realm-storage',
+      '--plugin-option', `gea.microtasks-namespace=gea::framework::app::generated::gea_${module.kind}_${module.id}`,
+    ]
+    if (cppBoard) moduleArgs.push('--cpp-board', cppBoard)
+    if (cxxStandard) moduleArgs.push('--cxx-standard', cxxStandard)
+    run('node', ['--stack_size=8192', '--max-old-space-size=32768', ...moduleArgs])
+    const list = fs.readFileSync(path.join(moduleOut, 'geatsc-sources.txt'), 'utf8').split(/\r?\n/).filter(Boolean)
+    nativeSources.push(...list.filter((source) => path.basename(source) !== 'gea_runtime_builtins.cpp'))
+  }
+  const listPath = path.join(outDir, 'geatsc-sources.txt')
+  const sources = fs.readFileSync(listPath, 'utf8').split(/\r?\n/).filter(Boolean)
+  const registry = path.join(outDir, 'gea_worker_modules.cpp')
+  writeWorkerRegistry([...nativeModules.values()], registry)
+  // The app entry and its native registrations must be in one archive member:
+  // constructor-only members are not extracted by ordinary static linking.
+  const nativeEntry = path.join(outDir, 'gea_native_entry.cpp')
+  fs.writeFileSync(nativeEntry, `#include ${JSON.stringify(sources[0])}\n#include ${JSON.stringify(registry)}\n`)
+  fs.writeFileSync(listPath, [nativeEntry, ...sources.slice(1), ...nativeSources].join('\n') + '\n')
+}
+
 
 process.stdout.write(`gea-vite-bundle=${bundlePath}\n`)
 if (moduleGraphOutDir) process.stdout.write(`module-graph=${path.join(moduleGraphOutDir, 'gea-module-graph.json')}\n`)

package/scripts/gea-bundle-type-hints.mjs

@@ -156,8 +156,16 @@ export function discoverLocalImport(source, srcId, localImports) {
   if (source.endsWith('.css')) return
   const base = resolveLocalImportBase(source, srcId)
   if (!base) return
+  // TypeScript's ESM imports name the emitted .js/.mjs/.cjs file while the
+  // source tree contains .ts/.mts/.cts. Follow those edges before staging.
+  const extension = path.extname(base)
+  const sourceExtensions = extension === '.js' ? ['.ts', '.tsx', '.d.ts']
+    : extension === '.mjs' ? ['.mts', '.d.mts']
+      : extension === '.cjs' ? ['.cts', '.d.cts'] : []
+  const stem = base.slice(0, base.length - extension.length)
   for (const candidate of [
     base,
+    ...sourceExtensions.map((extension) => stem + extension),
     base + '.tsx',
     base + '.ts',
     base + '.jsx',
@@ -177,7 +185,7 @@ export function discoverLocalImport(source, srcId, localImports) {
       // non-ASCII byte (`wOFF` header → "Unexpected character" at column 4).
       // Assets aren't parseable modules; skip them (the added-extension
       // candidates below are always JS/TS, so a genuine module still resolves).
-      if (!/\.(?:mjs|cjs|jsx?|tsx?)$/i.test(candidate)) break
+      if (!/\.(?:[cm]?[jt]s|jsx|tsx)$/i.test(candidate)) break
       localImports.push(candidate)
       break
     }

package/scripts/gea-embedded-compat-staging.mjs

@@ -5,6 +5,8 @@ export const COMPAT_STAGING_IGNORED_DIRECTORIES = Object.freeze([
   '.build',
   '.build-test',
   '.vite',
+  '.gea',
+  '.git',
   '.scratch',
   '.test-tmp',
   'generated-output',

package/scripts/gea-static-asset.mjs

@@ -0,0 +1,15 @@
+import fs from 'node:fs'
+import path from 'node:path'
+import { createHash } from 'node:crypto'
+
+// One identity for Vite's native module graph and the firmware lookup table.
+export function describeStaticAsset(source) {
+  const contents = fs.readFileSync(source)
+  const sha256 = createHash('sha256').update(contents).digest('hex')
+  return {
+    source,
+    bytes: contents.length,
+    sha256,
+    url: `gea-asset://sha256/${sha256}/${encodeURIComponent(path.basename(source))}`,
+  }
+}

package/scripts/gea-vite-module-graph-plugin.mjs

@@ -1,3 +1,4 @@
+import { describeStaticAsset } from './gea-static-asset.mjs'
 import crypto from 'node:crypto'
 import fs from 'node:fs'
 import path from 'node:path'
@@ -424,20 +425,6 @@ function entryReachableModuleIds(pluginContext, rawIdsByNormalizedId, allIds) {
   return allIds.filter((id) => reachable.has(id))
 }
 
-function describeStaticAsset(source) {
-  const contents = fs.readFileSync(source)
-  const sha256 = crypto.createHash('sha256').update(contents).digest('hex')
-  // The hash makes the logical URL collision-safe and stable for unchanged
-  // bytes. The basename remains available to native bundle adapters, while the
-  // manifest is the authoritative URL -> source mapping.
-  const basename = encodeURIComponent(path.basename(source))
-  return {
-    source,
-    bytes: contents.length,
-    sha256,
-    url: `gea-asset://sha256/${sha256}/${basename}`,
-  }
-}
 
 async function captureResolvedImports(pluginContext, state, id, code) {
   const normalized = normalizeModuleId(id)