@ekrooh/bare 0.1.0

package/dist/plugins-health-events.d.mts

@@ -0,0 +1,57 @@
+import { B as InvokeEnvelope } from "./index-DjulYFJL.mjs";
+//#region plugins/health/events.d.ts
+declare const healthSpecs: {
+  readonly ping: {
+    readonly pluginId: 'core.health';
+    readonly name: 'health.ping';
+    readonly args: {
+      message?: string;
+    };
+    readonly result: {
+      message: string;
+      ts: number;
+    };
+  };
+  readonly payloadEcho: {
+    readonly pluginId: 'core.health';
+    readonly name: 'health.payloadEcho';
+    readonly args: {
+      label: string;
+    };
+    readonly result: {
+      label: string;
+      payloadSize: number;
+    };
+  };
+  readonly roundtrip: {
+    readonly pluginId: 'core.health';
+    readonly name: 'health.roundtrip';
+    readonly args: Record<string, never>;
+    readonly result: {
+      pong: true;
+      ts: number;
+    };
+  };
+};
+declare const healthEvents: {
+  health: {
+    ping(message?: string): InvokeEnvelope<'health.ping', {
+      message?: string;
+    }, {
+      message: string;
+      ts: number;
+    }>;
+    payloadEcho(label: string, payload: Uint8Array | ArrayBuffer | string): InvokeEnvelope<'health.payloadEcho', {
+      label: string;
+    }, {
+      label: string;
+      payloadSize: number;
+    }>;
+    roundtrip(): InvokeEnvelope<'health.roundtrip', Record<string, never>, {
+      pong: true;
+      ts: number;
+    }>;
+  };
+};
+//#endregion
+export { healthEvents, healthSpecs };

package/dist/plugins-health-events.mjs

@@ -0,0 +1,35 @@
+import { invokeEvent } from "./index.mjs";
+//#region plugins/health/events.ts
+const healthSpecs = {
+	ping: {
+		pluginId: "core.health",
+		name: "health.ping",
+		args: {},
+		result: {}
+	},
+	payloadEcho: {
+		pluginId: "core.health",
+		name: "health.payloadEcho",
+		args: {},
+		result: {}
+	},
+	roundtrip: {
+		pluginId: "core.health",
+		name: "health.roundtrip",
+		args: {},
+		result: {}
+	}
+};
+const healthEvents = { health: {
+	ping(message = "ping") {
+		return invokeEvent(healthSpecs.ping, { message });
+	},
+	payloadEcho(label, payload) {
+		return invokeEvent(healthSpecs.payloadEcho, { label }, payload);
+	},
+	roundtrip() {
+		return invokeEvent(healthSpecs.roundtrip, {});
+	}
+} };
+//#endregion
+export { healthEvents, healthSpecs };

package/dist/plugins-media-events.d.mts

@@ -0,0 +1,39 @@
+import { B as InvokeEnvelope } from "./index-DjulYFJL.mjs";
+//#region plugins/media/events.d.ts
+type MediaKind = 'image' | 'video';
+type MediaResult = {
+  /** URL served by the worklet's loopback HTTP server (no bytes on the wire). */
+  url: string;
+  /** Absolute filesystem path of the picked file on the host. */
+  path: string;
+};
+declare const mediaSpecs: {
+  readonly pick: {
+    readonly pluginId: 'vendor.media';
+    readonly name: 'media.pick';
+    readonly args: {
+      kind?: MediaKind;
+    };
+    readonly result: MediaResult;
+  };
+  readonly capture: {
+    readonly pluginId: 'vendor.media';
+    readonly name: 'media.capture';
+    readonly args: {
+      kind?: MediaKind;
+    };
+    readonly result: MediaResult;
+  };
+};
+declare const mediaEvents: {
+  media: {
+    pick(kind?: MediaKind): InvokeEnvelope<'media.pick', {
+      kind?: MediaKind;
+    }, MediaResult>;
+    capture(kind?: MediaKind): InvokeEnvelope<'media.capture', {
+      kind?: MediaKind;
+    }, MediaResult>;
+  };
+};
+//#endregion
+export { MediaKind, MediaResult, mediaEvents, mediaSpecs };

package/dist/plugins-media-events.mjs

@@ -0,0 +1,27 @@
+import { invokeEvent } from "./index.mjs";
+//#region plugins/media/events.ts
+const MEDIA_INVOKE_TIMEOUT_MS = 3e5;
+const mediaSpecs = {
+	pick: {
+		pluginId: "vendor.media",
+		name: "media.pick",
+		args: {},
+		result: {}
+	},
+	capture: {
+		pluginId: "vendor.media",
+		name: "media.capture",
+		args: {},
+		result: {}
+	}
+};
+const mediaEvents = { media: {
+	pick(kind = "image") {
+		return invokeEvent(mediaSpecs.pick, { kind }, null, MEDIA_INVOKE_TIMEOUT_MS);
+	},
+	capture(kind = "image") {
+		return invokeEvent(mediaSpecs.capture, { kind }, null, MEDIA_INVOKE_TIMEOUT_MS);
+	}
+} };
+//#endregion
+export { mediaEvents, mediaSpecs };

package/dist/plugins-permissions-events.d.mts

@@ -0,0 +1,39 @@
+import { B as InvokeEnvelope } from "./index-DjulYFJL.mjs";
+//#region plugins/permissions/events.d.ts
+/** Canonical permission ids. Hosts map each to their platform equivalent. */
+type PermissionId = 'storage' | 'camera';
+type PermissionStatus = 'granted' | 'denied' | 'notDetermined' | 'unsupported';
+type PermissionResult = {
+  permission: PermissionId;
+  status: PermissionStatus;
+};
+declare const permissionSpecs: {
+  readonly request: {
+    readonly pluginId: 'core.permissions';
+    readonly name: 'permissions.request';
+    readonly args: {
+      permission: PermissionId;
+    };
+    readonly result: PermissionResult;
+  };
+  readonly status: {
+    readonly pluginId: 'core.permissions';
+    readonly name: 'permissions.status';
+    readonly args: {
+      permission: PermissionId;
+    };
+    readonly result: PermissionResult;
+  };
+};
+declare const permissionEvents: {
+  permissions: {
+    request(permission: PermissionId): InvokeEnvelope<'permissions.request', {
+      permission: PermissionId;
+    }, PermissionResult>;
+    status(permission: PermissionId): InvokeEnvelope<'permissions.status', {
+      permission: PermissionId;
+    }, PermissionResult>;
+  };
+};
+//#endregion
+export { PermissionId, PermissionResult, PermissionStatus, permissionEvents, permissionSpecs };

package/dist/plugins-permissions-events.mjs

@@ -0,0 +1,26 @@
+import { invokeEvent } from "./index.mjs";
+//#region plugins/permissions/events.ts
+const permissionSpecs = {
+	request: {
+		pluginId: "core.permissions",
+		name: "permissions.request",
+		args: {},
+		result: {}
+	},
+	status: {
+		pluginId: "core.permissions",
+		name: "permissions.status",
+		args: {},
+		result: {}
+	}
+};
+const permissionEvents = { permissions: {
+	request(permission) {
+		return invokeEvent(permissionSpecs.request, { permission });
+	},
+	status(permission) {
+		return invokeEvent(permissionSpecs.status, { permission });
+	}
+} };
+//#endregion
+export { permissionEvents, permissionSpecs };

package/dist/plugins.d.mts

@@ -0,0 +1,26 @@
+import { A as CapabilityDescriptor, G as PluginInvokeRequestHeader, K as PluginInvokeResponseHeader, Y as RuntimeTarget, q as PluginManifest } from "./index-DjulYFJL.mjs";
+import { t as LoopbackServer } from "./static-file-server-CxeI_mQr.mjs";
+//#region plugins/discovery/plugin.d.ts
+type DiscoveryPluginDeps = {
+  listBareCapabilities: () => Array<{
+    pluginId: string;
+    capabilities: string[];
+    events: string[];
+    runtimes: RuntimeTarget[];
+  }>;
+  queryHostCapabilities: () => Promise<CapabilityDescriptor[]>;
+};
+//#endregion
+//#region plugins/media/plugin.d.ts
+type MediaPluginDeps = {
+  /** Worklet-side loopback server exposing picked files to the web layer. */
+  staticServer: LoopbackServer;
+  /** Delegates the native pick/capture to the host (`HOST_INVOKE_REQUEST`). */
+  invokeOnHost: (header: PluginInvokeRequestHeader, payload: Uint8Array) => Promise<PluginInvokeResponseHeader | null>;
+};
+//#endregion
+//#region plugins/index.d.ts
+type DefaultPluginsDeps = DiscoveryPluginDeps & MediaPluginDeps;
+declare function createDefaultPlugins(deps: DefaultPluginsDeps): PluginManifest[];
+//#endregion
+export { DefaultPluginsDeps, type DiscoveryPluginDeps, type MediaPluginDeps, createDefaultPlugins };

package/dist/plugins.mjs

@@ -0,0 +1,2 @@
+import { t as createDefaultPlugins } from "./plugins-1KweEBct.mjs";
+export { createDefaultPlugins };

package/dist/runtime.d.mts

@@ -0,0 +1,96 @@
+import { A as CapabilityDescriptor, G as PluginInvokeRequestHeader, K as PluginInvokeResponseHeader, d as MessageProtocol, t as BareRuntimeContext, v as createPluginRegistry, y as createPluginRouter } from "./index-DjulYFJL.mjs";
+import { n as createLoopbackServer, t as LoopbackServer } from "./static-file-server-CxeI_mQr.mjs";
+//#region core/messages/host-ipc.d.ts
+type BareIpcLike = {
+  write(data: Uint8Array | Buffer | string): boolean;
+};
+declare function createHostIpcBridge(config: {
+  ipc: BareIpcLike;
+  protocol: MessageProtocol;
+}): {
+  tryConsumeDownstreamFromHost(raw: Uint8Array | ArrayBuffer | Buffer): boolean;
+  queryCapabilities(timeoutMs?: number): Promise<CapabilityDescriptor[]>;
+  invokeOnHost(header: PluginInvokeRequestHeader, payload: Uint8Array, timeoutMs?: number): Promise<PluginInvokeResponseHeader | null>;
+};
+//#endregion
+//#region core/server/websocket-server.d.ts
+/**
+ * Attaches the framed-protocol socket to the unified loopback server. The
+ * server owns the WebSocket upgrade (origin check, cookie/token auth, single
+ * client, idle timeout); this layer only routes decoded envelopes through the
+ * plugin router and writes responses back as raw frames.
+ */
+declare function attachWebSocketProtocol(server: LoopbackServer, context: BareRuntimeContext): void;
+//#endregion
+//#region core/lib/get-ipc.d.ts
+/**
+ * @fileoverview Bare IPC provider for Android (BareKit) and Sidecar (Bare.IPC)
+ */
+interface BareIPC extends NodeJS.EventEmitter {
+  read(n?: number): Buffer | null;
+  write(data: Buffer | string): boolean;
+  resume?(): void;
+  pause?(): void;
+}
+/**
+ * Returns the active IPC channel.
+ * In BareKit (Android), it uses BareKit.IPC.
+ * In Bare (Sidecar), it uses Bare.IPC.
+ */
+declare function getIPC(): BareIPC;
+//#endregion
+//#region core/runtime.d.ts
+/** Resolves the host-provided worklet configuration from `start(...)`
+ * arguments. On-device hosts pass `["<webAssets>", "<storage>", "<cache>"]`,
+ * landing at `Bare.argv[0..2]`; the Bare CLI (dev) passes the binary and the
+ * script path instead, so a missing/absent config means dev mode (auth off,
+ * fixed port, no handoff file). */
+declare function resolveWorkletConfig(): WorkletRuntimeOptions;
+type WorkletRuntimeOptions = {
+  /** Directory to serve at `/` (the built web app). */
+  webAssets?: string;
+  /** Durable app-sandbox directory: `handoff.json` + the p2p corestore. */
+  storage?: string;
+  /** Ephemeral app-sandbox directory: asset-cache, photo spool, temp. */
+  cache?: string;
+  /** Bind address. Defaults to `127.0.0.1`. */
+  host?: string;
+  /** Port to bind; `0` picks an ephemeral port (on-device). Defaults to an
+   * ephemeral port in device mode, 8080 in dev mode. */
+  port?: number;
+  /** Require the per-session token/cookie. Defaults to on in device mode. */
+  auth?: boolean;
+  /** Idle timeout (ms) after which an authenticated WebSocket is dropped. */
+  wsIdleTimeoutMs?: number;
+};
+type WorkletRuntimeConfig = {
+  webAssets?: string;
+  storage?: string;
+  cache?: string;
+  deviceMode: boolean;
+};
+interface WorkletRuntime {
+  protocol: MessageProtocol;
+  pluginRegistry: ReturnType<typeof createPluginRegistry>;
+  pluginRouter: ReturnType<typeof createPluginRouter>;
+  server: LoopbackServer;
+  hostBridge: ReturnType<typeof createHostIpcBridge> | null;
+  config: WorkletRuntimeConfig;
+  /** Binds the server, mounts the web app, attaches the protocol socket and
+   * (in device mode) writes the handoff file. Resolves to the credentials. */
+  start(): Promise<{
+    origin: string;
+    port: number;
+    token: string;
+  }>;
+  close(cb?: (err?: Error | null) => void): void;
+}
+/**
+ * Creates one worklet runtime — a per-instance, stateless factory (no
+ * module-scope singletons, no hardcoded port) so the dev/test backend can host
+ * N of them and a consumer worklet entry can be just "register plugins +
+ * wire p2p". Mirrors the reference wiring in `core/main.core.ts`.
+ */
+declare function createWorkletRuntime(options?: WorkletRuntimeOptions): WorkletRuntime;
+//#endregion
+export { type LoopbackServer, WorkletRuntime, WorkletRuntimeConfig, WorkletRuntimeOptions, attachWebSocketProtocol, createLoopbackServer, createWorkletRuntime, getIPC, resolveWorkletConfig };