@nebulahome/package-sdk 0.0.0-stage → 1.0.0

package/CHANGELOG.md

@@ -0,0 +1,26 @@
+# @nebulahome/package-sdk
+
+The SDK's version is the version of the package API the platform implements: a minor version adds
+to it, a major one breaks it, and a patch leaves it as it is.
+
+## 1.0.0
+
+The first public release.
+
+- `nebula.config.ts`: `definePackage`, `defineSettings`, `defineCard`, `defineEntityType`,
+  `definePage`, `defineContainer`, `defineCompose` and `field` declare a package, from which the
+  build writes `nebula.package.json` and `setup.json`.
+- `@nebulahome/package-sdk/server`: `defineServer`, and the context `start` is given - settings,
+  devices and entities, the package's own kinds of entity, methods for the interface and services
+  between packages.
+- `@nebulahome/package-sdk/ui`: the props of a page, a card and an entity view, and the hooks for
+  the package, its methods and settings, the house, the viewer, the theme and navigation.
+- `@nebulahome/package-sdk/components` and `/styles.css`: the part of the interface's design
+  system a package may draw with, and its Tailwind tokens.
+- `@nebulahome/package-sdk/vite`: `nebula()`, the Vite plugin that builds the interface with its
+  CSS scoped to the package and bundles the server.
+- `nebulahome-package validate`, `build` and `pack`: check the declaration the way the platform
+  does, build the release into `dist/`, and pack it into the `<id>-<version>.tgz` a GitHub release
+  carries with its entry for the package index.
+- `@nebulahome/package-sdk/testing`: `createTestContext`, to run `start` in a unit test with every
+  effect recorded.

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 NebulaHome
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -1,3 +1,142 @@
-# Temporary Holding Version
+# @nebulahome/package-sdk
 
-This version is a temporary placeholder for this package. An operational version to replace this has been submitted for review and is awaiting a staged release.
+What a NebulaHome package is written with. A **package** is something an installation adds to
+itself that is not a device brand - a broker, a recorder, a 3D view of the house, a music player.
+It runs a Node process, containers or a compose file, or nothing, and may add a page of its own,
+dashboard cards and views of its own kinds of entity to the interface.
+
+Start from the template, [nebulahome/pkg-template](https://github.com/nebulahome/pkg-template):
+a small package that uses each part of the SDK once. The full reference is `PACKAGES_DOCS.md` in
+the NebulaHome documentation.
+
+```bash
+pnpm add @nebulahome/package-sdk
+pnpm add -D vite typescript react @types/react @vitejs/plugin-react tailwindcss @tailwindcss/vite
+```
+
+## A package in three files
+
+```ts
+// nebula.config.ts - what the package is; the build writes the manifest from it
+import { defineCard, definePackage, defineSettings, field } from '@nebulahome/package-sdk';
+
+export const settings = defineSettings({
+  city: field.text({ label: 'City', isRequired: true }),
+  refreshMinutes: field.number({ label: 'Refresh every', unit: 'min', default: 30, isLive: true }),
+});
+
+export const forecast = defineCard({
+  id: 'forecast',
+  name: 'Forecast',
+  icon: 'cloud-sun',
+  sizes: ['wide'],
+  options: { days: field.number({ label: 'Days', min: 1, max: 7, default: 3 }) },
+});
+
+export default definePackage({
+  id: 'weather',
+  name: 'Weather',
+  description: 'Forecasts for where the house is.',
+  category: 'climate',
+  platform: '^1.0.0',
+  server: './src/server/index.ts',
+  settings,
+  cards: [forecast],
+  ui: { cards: { forecast: async () => import('./src/ui/forecast-card.js') } },
+});
+```
+
+```ts
+// src/server/index.ts - runs in a process of its own
+import { defineServer } from '@nebulahome/package-sdk/server';
+
+import { settings } from '../../nebula.config.js';
+
+export default defineServer({
+  settings,
+  start(ctx) {
+    ctx.rpc.method('forecast', { access: 'read' }, async () => fetchDays(ctx.settings.city));
+
+    return undefined;
+  },
+});
+```
+
+```tsx
+// src/ui/forecast-card.tsx - any React, any CSS; the interface draws only the frame
+import { usePackageRpc, type CardProps } from '@nebulahome/package-sdk/ui';
+
+import type { forecast } from '../../nebula.config.js';
+
+export default function ForecastCard({ options, title, name }: CardProps<typeof forecast>) {
+  const days = usePackageRpc<Day[]>('forecast');
+
+  return <Strip title={title ?? name} days={days.data?.slice(0, options.days)} />;
+}
+```
+
+```ts
+// vite.config.ts
+import tailwindcss from '@tailwindcss/vite';
+import react from '@vitejs/plugin-react';
+import { defineConfig } from 'vite';
+
+import { nebula } from '@nebulahome/package-sdk/vite';
+
+export default defineConfig({ plugins: [react(), tailwindcss(), nebula()] });
+```
+
+## Entry points
+
+| Import                    | What                                                                                                                                                                                                    |
+| ------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| `@nebulahome/package-sdk` | `definePackage`, `defineSettings`, `defineCard`, `defineEntityType`, `definePage`, `defineContainer`, `defineCompose`, `field`, entity id helpers, `SDK_VERSION`, the value types.                      |
+| `/server`                 | `defineServer`, and the context `start` is given: settings (live or restart), devices and entities, typed custom entities, the rest of the house, methods for the interface, services between packages. |
+| `/ui`                     | The props of a page, a card and an entity view; hooks for the package, its methods, its settings, the house, the viewer, the theme; navigation inside the package's page and to the platform's places.  |
+| `/components`             | The part of the interface's design system a package may draw with.                                                                                                                                      |
+| `/vite`                   | `nebula()`, the Vite plugin that builds both halves: the interface in chunks with its CSS scoped to the package, the server bundled whole.                                                              |
+| `/testing`                | `createTestContext()`: run `start` in a unit test, every effect recorded.                                                                                                                               |
+| `/styles.css`             | The interface's Tailwind tokens, to `@reference`.                                                                                                                                                       |
+
+The `nebulahome-package` command checks, builds and packs a package:
+
+```bash
+nebulahome-package validate   # the declaration holds together, as the platform checks it
+nebulahome-package build      # dist/: what an installation runs
+nebulahome-package pack       # <id>-<version>.tgz and its entry for the package index
+```
+
+## Compatibility
+
+The SDK follows SemVer, and its types are the contract: the platform implements them, so the
+package and the platform cannot drift apart unnoticed. A package's manifest records the SDK it was
+built with (`sdk: ^<major>.<minor>.0`), and the platform refuses to install or start a release it
+does not implement. A minor of the SDK is published only together with a platform release that
+implements it. React's major is part of the contract.
+
+## Releasing the SDK
+
+For the platform's maintainers. The packet-manager reads the version it implements from this
+`package.json`, so the version is raised by hand:
+
+- **patch** - a fix, or a change to the command, the build, the tests' helpers or the
+  documentation that leaves what a package can use as it is. Packages keep declaring
+  `^<major>.<minor>.0`, so it is released whenever it is ready.
+- **minor** - the API grows. Raise it in the first commit that grows it, so a package using the
+  new part is never installed on a platform without it; release it with the platform that
+  implements it.
+- **major** - the API breaks: packages built before are refused until they are built again.
+
+Every change of the release goes into `CHANGELOG.md`. Then, from the commit released:
+
+```sh
+git tag package-sdk@<version> && git push origin package-sdk@<version>
+```
+
+`.github/workflows/release-package-sdk.yml` checks the tag says the package's version, runs the
+SDK's gates and publishes a GitHub release with the archive npm will receive. The maintainer
+publishes that archive, signed in to npm:
+
+```sh
+npm publish nebulahome-package-sdk-<version>.tgz
+```

package/dist/chunks/context.d.ts

@@ -0,0 +1,369 @@
+import { G as CapabilityState, V as CapabilityCommand, X as EntityStateClass, Y as DeclaredCapabilities, a as SettingsOf, ct as EntityDomain, d as EntityTypeDefinition, et as ReportedCapabilityState, f as ValuesOf, i as SettingsDefinition, lt as EntityId, r as JsonValue, s as ArgsOf, t as JsonObject, u as CommandsOf } from "./json.js";
+//#region src/schema.d.ts
+/**
+ * What checks a value that crosses into a package - a method's input, a service's answer: any
+ * [Standard Schema](https://standardschema.dev) - zod 4, valibot, arktype - or an object with
+ * zod's `safeParse`. The SDK carries no validation library of its own.
+ *
+ * The Standard Schema interface is written out here, as its authors ask libraries to do, rather
+ * than taken as a dependency.
+ */
+/** One problem a Standard Schema found. */
+type SchemaIssue = {
+  readonly message: string;
+  readonly path?: readonly (PropertyKey | {
+    readonly key: PropertyKey;
+  })[] | undefined;
+};
+/** What a Standard Schema's `validate` gives back. */
+type StandardResult<TOutput> = {
+  readonly value: TOutput;
+  readonly issues?: undefined;
+} | {
+  readonly issues: readonly SchemaIssue[];
+};
+/** The Standard Schema interface, version 1. */
+type StandardSchemaV1<TInput = unknown, TOutput = TInput> = {
+  readonly '~standard': {
+    readonly version: 1;
+    readonly vendor: string;
+    readonly validate: (value: unknown) => StandardResult<TOutput> | Promise<StandardResult<TOutput>>;
+    readonly types?: {
+      readonly input: TInput;
+      readonly output: TOutput;
+    } | undefined;
+  };
+};
+/** An object that checks a value the way zod's `safeParse` does. */
+type SafeParser<TOutput> = {
+  readonly safeParse: (value: unknown) => {
+    readonly success: true;
+    readonly data: TOutput;
+  } | {
+    readonly success: false;
+    readonly error: unknown;
+  };
+};
+/** What the SDK takes to check a value: a Standard Schema, or a `safeParse`. */
+type Schema<TOutput> = StandardSchemaV1<unknown, TOutput> | SafeParser<TOutput>;
+//#endregion
+//#region src/server/context.d.ts
+/** A value, or a promise of one. */
+type Awaitable<TValue> = TValue | Promise<TValue>;
+/** Stops what a registration started: a handler, a subscription. */
+type Unsubscribe = () => void;
+/** One log method: `(fields, message?)` or `(message)`. */
+type LogMethod = {
+  (fields: object, message?: string): void;
+  (message: string): void;
+};
+/** The package's logger: its lines are the package's log on its page. */
+type Logger = {
+  readonly trace: LogMethod;
+  readonly debug: LogMethod;
+  readonly info: LogMethod;
+  readonly warn: LogMethod;
+  readonly error: LogMethod;
+  readonly fatal: LogMethod;
+  /**
+   * A logger whose every line carries these fields too.
+   *
+   * @param fields - What each line adds.
+   * @returns The logger.
+   */
+  readonly child: (fields: Record<string, unknown>) => Logger;
+};
+/** One entity of a platform capability, as `devices.sync` takes it. */
+type CapabilityEntityInput = {
+  /** What follows the package's prefix in its id: `temperature` → `sensor.weather_temperature`. */
+  readonly objectId: string;
+  readonly name: string;
+  readonly domain: EntityDomain;
+  readonly capabilities: DeclaredCapabilities;
+  readonly icon?: string;
+  /**
+   * The unit the device gives its numbers in. For a sensor of a class the platform knows, the
+   * platform registers the class's own unit and converts every number reported - kW to W, °F to
+   * °C - so report what the device says, as it says it.
+   */
+  readonly unitOfMeasurement?: string;
+  /**
+   * What the number measures: `temperature`, `power`, `energy`. A unit the class cannot be
+   * converted from drops the class, and the number is kept as it comes.
+   */
+  readonly deviceClass?: string;
+  /** How its numbers add up; the class's own when not said. */
+  readonly stateClass?: EntityStateClass;
+  readonly displayPrecision?: number;
+};
+/** One entity of one of the package's own entity types, as `devices.sync` takes it. */
+type CustomEntityInput = {
+  readonly objectId: string;
+  readonly name: string;
+  /** The entity type: its domain is `custom`, its capability the type's. */
+  readonly type: EntityTypeDefinition;
+  readonly icon?: string;
+};
+/** One entity, as `devices.sync` takes it. */
+type EntityInput = CapabilityEntityInput | CustomEntityInput;
+/** One device, as `devices.sync` takes it. */
+type DeviceInput = {
+  /** Its own id at the package: stable, what finds it again after a restart. */
+  readonly externalId: string;
+  /** What it starts as called; the owner's name, once given, outlives it. */
+  readonly name: string;
+  readonly icon?: string;
+  readonly manufacturer?: string;
+  readonly model?: string;
+  readonly swVersion?: string;
+  readonly entities: readonly EntityInput[];
+};
+/** What the platform did with the package's devices. */
+type SyncResult = {
+  readonly devices: readonly {
+    readonly deviceId: string;
+    readonly externalId: string;
+    readonly entityIds: readonly EntityId[];
+  }[];
+  /** Entities written by no one, and why: log them. */
+  readonly refused: readonly {
+    readonly entityId: string;
+    readonly reason: string;
+  }[];
+  /** Devices gone from the list but kept, because an alias reads one of their entities. */
+  readonly kept: readonly string[];
+};
+/** What a report may say besides the state. */
+type ReportOptions = {
+  /** What no capability covers, as JSON. */
+  readonly attributes?: JsonObject;
+  /** False while the thing the entity stands for cannot be reached. */
+  readonly isAvailable?: boolean;
+};
+/** One entity of the house, as it stands. */
+type EntitySnapshot = {
+  readonly entityId: EntityId;
+  readonly state: CapabilityState;
+  readonly attributes: JsonObject;
+  readonly isAvailable: boolean;
+  /** When its state last differed, ISO 8601. */
+  readonly lastChanged: string;
+  /** When it was last reported, ISO 8601. */
+  readonly lastUpdated: string;
+};
+/** A change of an entity's state. */
+type StateChange = {
+  readonly entityId: EntityId;
+  readonly current: EntitySnapshot;
+  /** What it was; absent on the first report after the platform started. */
+  readonly previous?: EntitySnapshot;
+};
+/** Which entities: of a domain, or by id. Neither is every entity. */
+type EntityFilter = {
+  readonly domain?: EntityDomain;
+  readonly entityIds?: readonly EntityId[];
+};
+/** Who may call a method: whoever may read packages, or whoever may configure them. */
+type RpcAccess = 'read' | 'configure';
+/** Who called a method of the package's interface. */
+type RpcCaller = {
+  readonly userId: string;
+  readonly username: string;
+  readonly role: string;
+};
+/** What a method's handler is told besides its input. */
+type RpcCall = {
+  readonly caller: RpcCaller;
+};
+/** What a service's handler is told besides its input. */
+type ServiceCall = {
+  /** The package or service that called, by its id. */
+  readonly caller: string;
+};
+/** A change of the package's settings that reached the running process. */
+type SettingsChange<TValues> = {
+  /** Every setting, as it stands now. */
+  readonly values: TValues;
+  /** The keys that changed. */
+  readonly changed: readonly (keyof TValues & string)[];
+};
+/** The values of the settings a server declared, or plain JSON when it declared none. */
+type ServerSettings<TSettings> = [TSettings] extends [SettingsDefinition] ? SettingsOf<TSettings> : JsonObject;
+/** A command of one of the package's entity types, as its handler is given it. */
+type CustomCommand<TArgs> = {
+  readonly entityId: EntityId;
+  readonly objectId: string;
+  readonly args: TArgs;
+};
+/** The entities of one of the package's entity types, typed by its declaration. */
+type CustomEntities<TType extends EntityTypeDefinition> = {
+  /**
+   * The id of one of the package's entities of this type.
+   *
+   * @param objectId - What follows the package's prefix.
+   * @returns `custom.<prefix>_<objectId>`.
+   */
+  readonly entityId: (objectId: string) => EntityId;
+  /**
+   * Reports some or all of an entity's values; an optional field may be null.
+   *
+   * @param entityId - The entity.
+   * @param values - The values that changed, or all of them.
+   * @param options - Its attributes and availability.
+   */
+  readonly report: (entityId: EntityId, values: Partial<ValuesOf<TType>>, options?: ReportOptions) => void;
+  /**
+   * Handles one of the type's commands; a throw is the command's failure.
+   *
+   * @param command - The command's id.
+   * @param handler - What it does with the entity and the arguments.
+   * @returns What stops the handler.
+   * @throws {Error} When the command has a handler already.
+   */
+  readonly onCommand: <TCommand extends CommandsOf<TType>>(command: TCommand, handler: (command: CustomCommand<ArgsOf<TType, TCommand>>) => Awaitable<void>) => Unsubscribe;
+};
+/** Registering a method of the package's interface. */
+type RpcMethod = {
+  (name: string, options: {
+    readonly access: RpcAccess;
+  }, handler: (input: JsonValue | undefined, call: RpcCall) => Awaitable<JsonValue | undefined>): void;
+  <TInput>(name: string, options: {
+    readonly access: RpcAccess;
+    readonly input: Schema<TInput>;
+  }, handler: (input: TInput, call: RpcCall) => Awaitable<JsonValue | undefined>): void;
+};
+/** Offering a service. */
+type ServiceProvide = {
+  (name: string, handler: (input: unknown, call: ServiceCall) => Awaitable<JsonValue | undefined>): void;
+  <TInput>(name: string, options: {
+    readonly input: Schema<TInput>;
+  }, handler: (input: TInput, call: ServiceCall) => Awaitable<JsonValue | undefined>): void;
+};
+/** Calling a service. */
+type ServiceCallFunction = {
+  (target: string, name: string, input?: JsonValue, options?: {
+    readonly timeoutMs?: number;
+  }): Promise<unknown>;
+  <TOutput>(target: string, name: string, input: JsonValue, options: {
+    readonly timeoutMs?: number;
+    readonly output: Schema<TOutput>;
+  }): Promise<TOutput>;
+};
+/** What the platform hands `start`. */
+type ServerContext<TSettings = undefined> = {
+  /** The package's id. */
+  readonly id: string;
+  /** The release running. */
+  readonly version: string;
+  readonly platform: {
+    readonly version: string;
+  };
+  /** The SDK version the platform implements. */
+  readonly sdk: {
+    readonly version: string;
+  };
+  /** What the owner saved, defaults applied, secrets open. Current after a live change. */
+  readonly settings: ServerSettings<TSettings>;
+  /**
+   * Hears a change of live settings, which reaches the process instead of restarting it.
+   *
+   * @param handler - What to do with the settings as they now stand.
+   * @returns What stops it hearing.
+   */
+  readonly onSettingsChange: (handler: (change: SettingsChange<ServerSettings<TSettings>>) => Awaitable<void>) => Unsubscribe;
+  /** `packages/<id>/data/`: what it keeps, in every backup. */
+  readonly dataDir: string;
+  /** `cache/packages/<id>/`: what it can make again, in no backup. */
+  readonly cacheDir: string;
+  /** Aborted when the package is asked to stop. */
+  readonly signal: AbortSignal;
+  readonly logger: Logger;
+  /**
+   * One of its entities' ids.
+   *
+   * @param domain - The entity's domain.
+   * @param objectId - What follows the package's prefix.
+   * @returns `<domain>.<prefix>_<objectId>`.
+   */
+  readonly entityId: (domain: EntityDomain, objectId: string) => EntityId;
+  /**
+   * The object id of one of its own entities.
+   *
+   * @param entityId - The entity.
+   * @returns What follows the package's prefix, or undefined for anyone else's entity.
+   */
+  readonly objectIdOf: (entityId: string) => string | undefined;
+  readonly devices: {
+    /**
+     * Registers every device and entity the package has, whole: what is left out is removed.
+     *
+     * @param devices - Every device, with its entities.
+     * @param options - How long the platform has to answer.
+     * @param options.timeoutMs - In milliseconds; 15 seconds when not said.
+     * @returns What it wrote, and what it refused.
+     */
+    readonly sync: (devices: readonly DeviceInput[], options?: {
+      readonly timeoutMs?: number;
+    }) => Promise<SyncResult>;
+    /**
+     * Reports an entity's state, through the pipeline every report goes through.
+     *
+     * @param entityId - The entity.
+     * @param state - One entry per capability.
+     * @param options - Its attributes and availability.
+     */
+    readonly report: (entityId: EntityId, state: ReportedCapabilityState, options?: ReportOptions) => void;
+    /**
+     * Handles the commands routed to its entities; a throw is the command's failure.
+     *
+     * @param handler - What it does with one.
+     * @returns What stops the handler.
+     * @throws {Error} When there is a handler already.
+     */
+    readonly onCommand: (handler: (command: CapabilityCommand) => Awaitable<void>) => Unsubscribe;
+  };
+  /**
+   * The entities of one of its entity types, typed.
+   *
+   * @param type - The entity type.
+   * @returns Its entities' ids, reports and commands.
+   */
+  readonly custom: <TType extends EntityTypeDefinition>(type: TType) => CustomEntities<TType>;
+  /** The rest of the house, read only. */
+  readonly entities: {
+    /**
+     * One entity, as it stands.
+     *
+     * @param entityId - The entity.
+     * @returns It, or undefined when there is none.
+     */
+    readonly get: (entityId: EntityId) => Promise<EntitySnapshot | undefined>;
+    /**
+     * Every entity, or those of a domain or by id.
+     *
+     * @param filter - Which.
+     * @returns Them.
+     */
+    readonly list: (filter?: EntityFilter) => Promise<readonly EntitySnapshot[]>;
+    /**
+     * Hears every change of the entities a filter names.
+     *
+     * @param filter - Which.
+     * @param handler - What to do with a change.
+     * @returns What stops it hearing.
+     */
+    readonly subscribe: (filter: EntityFilter, handler: (change: StateChange) => Awaitable<void>) => Unsubscribe;
+  };
+  readonly rpc: {
+    /** Registers a method its interface calls; a name registered twice throws. */
+    readonly method: RpcMethod;
+  };
+  readonly services: {
+    /** Answers a service other packages call; a name provided twice, or reserved, throws. */
+    readonly provide: ServiceProvide;
+    /** Calls another package's or the platform's service. */
+    readonly call: ServiceCallFunction;
+  };
+};
+//#endregion
+export { StandardSchemaV1 as A, StateChange as C, Schema as D, SafeParser as E, SchemaIssue as O, SettingsChange as S, Unsubscribe as T, ServerContext as _, CustomEntityInput as a, ServiceCallFunction as b, EntityInput as c, Logger as d, ReportOptions as f, RpcMethod as g, RpcCaller as h, CustomEntities as i, StandardResult as k, EntitySnapshot as l, RpcCall as m, CapabilityEntityInput as n, DeviceInput as o, RpcAccess as p, CustomCommand as r, EntityFilter as s, Awaitable as t, LogMethod as u, ServerSettings as v, SyncResult as w, ServiceProvide as x, ServiceCall as y };

package/dist/chunks/host.js

@@ -0,0 +1,53 @@
+//#region src/host.ts
+/** The key of the interface's implementation of `/ui`. */
+const UI_MODULE = "@nebulahome/package-sdk/ui@1";
+/** The key of the interface's implementation of `/components`. */
+const COMPONENTS_MODULE = "@nebulahome/package-sdk/components@1";
+/**
+* Says whether a value is a record.
+*
+* @param value - The value.
+* @returns True for a non-null object.
+*/
+function isRecord(value) {
+	return typeof value === "object" && value !== null;
+}
+/**
+* The SDK version the interface implements, as it says.
+*
+* @returns It, or undefined outside the interface.
+*/
+function hostSdkVersion() {
+	const nebula = Reflect.get(globalThis, "__nebula");
+	const version = isRecord(nebula) ? nebula["sdk"] : void 0;
+	return typeof version === "string" ? version : void 0;
+}
+/**
+* One member of a module the interface lends.
+*
+* @param module - The module's key.
+* @param name - The member.
+* @param since - The SDK version that added it.
+* @returns The interface's implementation of it.
+* @throws {Error} When there is no interface, or it does not implement the member.
+*/
+function hostMember(module, name, since) {
+	const nebula = Reflect.get(globalThis, "__nebula");
+	const modules = isRecord(nebula) ? nebula["modules"] : void 0;
+	const lent = isRecord(modules) ? modules[module] : void 0;
+	const member = isRecord(lent) ? lent[name] : void 0;
+	/**
+	* Says whether the member is there: a function, or a component React wrapped. What it is
+	* beyond that the interface vouches for, its implementation being type-checked against the
+	* SDK's declaration.
+	*
+	* @param value - The member.
+	* @returns True when it can be called or drawn.
+	*/
+	const isLent = (value) => typeof value === "function" || isRecord(value) && "$$typeof" in value;
+	if (isLent(member)) return member;
+	const version = hostSdkVersion();
+	throw new Error(version === void 0 ? `${name} is lent by the NebulaHome interface, and there is none here` : `${name} needs package SDK ${since}; this interface implements ${version}`);
+}
+//#endregion
+export { UI_MODULE as n, hostMember as r, COMPONENTS_MODULE as t };