@kromatv/sdk 0.1.40-canary.0

package/types/registry/src/client.d.ts

@@ -0,0 +1,23 @@
+import { ModuleRecord, RegistryDescriptor, type RegistryEntry, type RegistryVersion } from './documents/index.ts';
+export type FetchJson = (url: string) => Promise<unknown>;
+/** The highest version satisfying `range`, or `null`. */
+export declare function pickVersion(versions: string[], range: string): string | null;
+/** Verify bytes against an `sha256-<base64>` integrity string. */
+export declare function verifyIntegrity(bytes: Uint8Array, integrity: string): Promise<boolean>;
+/** What a substring search reads: everything a store card puts on screen. */
+export type Searchable = Pick<RegistryEntry, 'id' | 'name' | 'description' | 'keywords' | 'tags'>;
+/** Substring match over everything a store card shows. */
+export declare function matches(entry: Searchable, query: string): boolean;
+export interface Resolved {
+    version: string;
+    release: RegistryVersion;
+}
+export interface RegistryClient {
+    descriptor(): Promise<RegistryDescriptor>;
+    index(): Promise<RegistryEntry[]>;
+    module(id: string): Promise<ModuleRecord>;
+    search(query: string): Promise<RegistryEntry[]>;
+    /** The version a `range` (or a channel name like `beta`) installs to. */
+    resolve(id: string, range: string): Promise<Resolved | null>;
+}
+export declare function createRegistryClient(baseUrl: string, fetchJson: FetchJson): RegistryClient;

package/types/registry/src/documents/index.d.ts

@@ -0,0 +1,6 @@
+import type { z } from 'zod';
+/** The document contract this build serves and reads. */
+export declare const REGISTRY_API_VERSION = 1;
+/** Every published document version, keyed by the `apiVersion` it describes. */
+export declare const DOCUMENT_SCHEMAS: Record<number, Record<string, z.ZodType>>;
+export { Contribution, Integrity, ModuleRecord, PointDef, PointReq, RegistryArtifact, RegistryDescriptor, RegistryEntry, RegistryIndex, RegistryVersion, } from './v1.ts';

package/types/registry/src/documents/v1.d.ts

@@ -0,0 +1,197 @@
+import { z } from 'zod';
+/** Subresource-Integrity form of a sha256 digest: `sha256-<base64>`. */
+export declare const Integrity: z.ZodString;
+export declare const PointDef: z.ZodObject<{
+    name: z.ZodString;
+    version: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+    methods: z.ZodOptional<z.ZodNullable<z.ZodArray<z.ZodString>>>;
+}, z.core.$catchall<z.ZodJSONSchema>>;
+export declare const Contribution: z.ZodObject<{
+    point: z.ZodString;
+    version: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+    id: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+}, z.core.$catchall<z.ZodJSONSchema>>;
+export declare const PointReq: z.ZodObject<{
+    point: z.ZodString;
+    version: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    id: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    optional: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
+}, z.core.$catchall<z.ZodJSONSchema>>;
+export declare const RegistryArtifact: z.ZodObject<{
+    target: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    url: z.ZodString;
+    size: z.ZodNumber;
+    integrity: z.ZodString;
+    contentHash: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+}, z.core.$strip>;
+export type RegistryArtifact = z.infer<typeof RegistryArtifact>;
+/** Everything that is true of one *version* of a module. */
+export declare const RegistryVersion: z.ZodObject<{
+    schemaVersion: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+    engines: z.ZodOptional<z.ZodNullable<z.ZodRecord<z.ZodString, z.ZodString>>>;
+    library: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
+    dependencies: z.ZodOptional<z.ZodNullable<z.ZodRecord<z.ZodString, z.ZodString>>>;
+    optionalDependencies: z.ZodOptional<z.ZodNullable<z.ZodRecord<z.ZodString, z.ZodString>>>;
+    definesPoints: z.ZodOptional<z.ZodNullable<z.ZodArray<z.ZodObject<{
+        name: z.ZodString;
+        version: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+        methods: z.ZodOptional<z.ZodNullable<z.ZodArray<z.ZodString>>>;
+    }, z.core.$catchall<z.ZodJSONSchema>>>>>;
+    contributes: z.ZodOptional<z.ZodNullable<z.ZodArray<z.ZodObject<{
+        point: z.ZodString;
+        version: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+        id: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    }, z.core.$catchall<z.ZodJSONSchema>>>>>;
+    consumes: z.ZodOptional<z.ZodNullable<z.ZodArray<z.ZodObject<{
+        point: z.ZodString;
+        version: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        id: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        optional: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
+    }, z.core.$catchall<z.ZodJSONSchema>>>>>;
+    artifacts: z.ZodArray<z.ZodObject<{
+        target: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        url: z.ZodString;
+        size: z.ZodNumber;
+        integrity: z.ZodString;
+        contentHash: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+export type RegistryVersion = z.infer<typeof RegistryVersion>;
+/** `GET /index.json`: one entry per module, carrying the version a bare install
+ *  resolves to. Enough to render a store and judge compatibility in ONE request. */
+export declare const RegistryEntry: z.ZodObject<{
+    schemaVersion: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+    engines: z.ZodOptional<z.ZodNullable<z.ZodRecord<z.ZodString, z.ZodString>>>;
+    library: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
+    dependencies: z.ZodOptional<z.ZodNullable<z.ZodRecord<z.ZodString, z.ZodString>>>;
+    optionalDependencies: z.ZodOptional<z.ZodNullable<z.ZodRecord<z.ZodString, z.ZodString>>>;
+    definesPoints: z.ZodOptional<z.ZodNullable<z.ZodArray<z.ZodObject<{
+        name: z.ZodString;
+        version: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+        methods: z.ZodOptional<z.ZodNullable<z.ZodArray<z.ZodString>>>;
+    }, z.core.$catchall<z.ZodJSONSchema>>>>>;
+    contributes: z.ZodOptional<z.ZodNullable<z.ZodArray<z.ZodObject<{
+        point: z.ZodString;
+        version: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+        id: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    }, z.core.$catchall<z.ZodJSONSchema>>>>>;
+    consumes: z.ZodOptional<z.ZodNullable<z.ZodArray<z.ZodObject<{
+        point: z.ZodString;
+        version: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        id: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        optional: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
+    }, z.core.$catchall<z.ZodJSONSchema>>>>>;
+    artifacts: z.ZodArray<z.ZodObject<{
+        target: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        url: z.ZodString;
+        size: z.ZodNumber;
+        integrity: z.ZodString;
+        contentHash: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    }, z.core.$strip>>;
+    id: z.ZodString;
+    name: z.ZodString;
+    description: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    author: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    homepage: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    license: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    keywords: z.ZodOptional<z.ZodNullable<z.ZodArray<z.ZodString>>>;
+    tags: z.ZodOptional<z.ZodNullable<z.ZodArray<z.ZodString>>>;
+    icon: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    version: z.ZodString;
+}, z.core.$strip>;
+export type RegistryEntry = z.infer<typeof RegistryEntry>;
+export declare const RegistryIndex: z.ZodArray<z.ZodObject<{
+    schemaVersion: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+    engines: z.ZodOptional<z.ZodNullable<z.ZodRecord<z.ZodString, z.ZodString>>>;
+    library: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
+    dependencies: z.ZodOptional<z.ZodNullable<z.ZodRecord<z.ZodString, z.ZodString>>>;
+    optionalDependencies: z.ZodOptional<z.ZodNullable<z.ZodRecord<z.ZodString, z.ZodString>>>;
+    definesPoints: z.ZodOptional<z.ZodNullable<z.ZodArray<z.ZodObject<{
+        name: z.ZodString;
+        version: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+        methods: z.ZodOptional<z.ZodNullable<z.ZodArray<z.ZodString>>>;
+    }, z.core.$catchall<z.ZodJSONSchema>>>>>;
+    contributes: z.ZodOptional<z.ZodNullable<z.ZodArray<z.ZodObject<{
+        point: z.ZodString;
+        version: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+        id: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    }, z.core.$catchall<z.ZodJSONSchema>>>>>;
+    consumes: z.ZodOptional<z.ZodNullable<z.ZodArray<z.ZodObject<{
+        point: z.ZodString;
+        version: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        id: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        optional: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
+    }, z.core.$catchall<z.ZodJSONSchema>>>>>;
+    artifacts: z.ZodArray<z.ZodObject<{
+        target: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        url: z.ZodString;
+        size: z.ZodNumber;
+        integrity: z.ZodString;
+        contentHash: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    }, z.core.$strip>>;
+    id: z.ZodString;
+    name: z.ZodString;
+    description: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    author: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    homepage: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    license: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    keywords: z.ZodOptional<z.ZodNullable<z.ZodArray<z.ZodString>>>;
+    tags: z.ZodOptional<z.ZodNullable<z.ZodArray<z.ZodString>>>;
+    icon: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    version: z.ZodString;
+}, z.core.$strip>>;
+/** `GET /m/{id}.json`: every version the registry serves, plus the named
+ *  channels that point into them. */
+export declare const ModuleRecord: z.ZodObject<{
+    id: z.ZodString;
+    name: z.ZodString;
+    description: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    author: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    homepage: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    license: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    keywords: z.ZodOptional<z.ZodNullable<z.ZodArray<z.ZodString>>>;
+    tags: z.ZodOptional<z.ZodNullable<z.ZodArray<z.ZodString>>>;
+    icon: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    apiVersion: z.ZodNumber;
+    latest: z.ZodString;
+    distTags: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodString>>;
+    versions: z.ZodRecord<z.ZodString, z.ZodObject<{
+        schemaVersion: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+        engines: z.ZodOptional<z.ZodNullable<z.ZodRecord<z.ZodString, z.ZodString>>>;
+        library: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
+        dependencies: z.ZodOptional<z.ZodNullable<z.ZodRecord<z.ZodString, z.ZodString>>>;
+        optionalDependencies: z.ZodOptional<z.ZodNullable<z.ZodRecord<z.ZodString, z.ZodString>>>;
+        definesPoints: z.ZodOptional<z.ZodNullable<z.ZodArray<z.ZodObject<{
+            name: z.ZodString;
+            version: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+            methods: z.ZodOptional<z.ZodNullable<z.ZodArray<z.ZodString>>>;
+        }, z.core.$catchall<z.ZodJSONSchema>>>>>;
+        contributes: z.ZodOptional<z.ZodNullable<z.ZodArray<z.ZodObject<{
+            point: z.ZodString;
+            version: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+            id: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        }, z.core.$catchall<z.ZodJSONSchema>>>>>;
+        consumes: z.ZodOptional<z.ZodNullable<z.ZodArray<z.ZodObject<{
+            point: z.ZodString;
+            version: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+            id: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+            optional: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
+        }, z.core.$catchall<z.ZodJSONSchema>>>>>;
+        artifacts: z.ZodArray<z.ZodObject<{
+            target: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+            url: z.ZodString;
+            size: z.ZodNumber;
+            integrity: z.ZodString;
+            contentHash: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        }, z.core.$strip>>;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+export type ModuleRecord = z.infer<typeof ModuleRecord>;
+/** `GET /registry.json`: who this registry is and which ids it serves. */
+export declare const RegistryDescriptor: z.ZodObject<{
+    apiVersion: z.ZodNumber;
+    name: z.ZodString;
+    url: z.ZodString;
+    modules: z.ZodArray<z.ZodString>;
+}, z.core.$strip>;
+export type RegistryDescriptor = z.infer<typeof RegistryDescriptor>;

package/types/registry/src/index.d.ts

@@ -0,0 +1,7 @@
+export { buildDescriptor, buildIndex, buildModuleRecord, type KnownVersions, sriFromHex, } from './build.ts';
+export { createRegistryClient, type FetchJson, matches, pickVersion, type RegistryClient, type Resolved, type Searchable, verifyIntegrity, } from './client.ts';
+export { Contribution, DOCUMENT_SCHEMAS, Integrity, ModuleRecord, PointDef, PointReq, REGISTRY_API_VERSION, RegistryArtifact, RegistryDescriptor, RegistryEntry, RegistryIndex, RegistryVersion, } from './documents/index.ts';
+export { ArtifactRef, ConfigField, CoreScope, DescribedModule, dependenciesOf, MANIFEST_SCHEMAS, Manifest, MODULE_SCHEMA_VERSION, optionalDependenciesOf, REVERSE_DNS_ID, Storage, speaksCurrentSchema, } from './manifest/index.ts';
+export { channelOf, compareRaw, parse, satisfies, type Version } from './semver.ts';
+export { type JsonSchema, jsonSchema, publishesSchema, SCHEMA_NAMES, type SchemaName, schemaPath, schemaVersionOf, } from './spec.ts';
+export { base64, trimTrailingSlashes } from './text.ts';

package/types/registry/src/manifest/index.d.ts

@@ -0,0 +1,9 @@
+import type { z } from 'zod';
+/** The manifest schema this build speaks. Distinct from the documents'
+ *  `apiVersion`: one versions a file a module author writes, the other versions
+ *  the documents a registry serves, and they move independently. */
+export declare const MODULE_SCHEMA_VERSION = 2;
+/** Every published manifest version, so a schema URL keeps resolving after the
+ *  current one moves on. */
+export declare const MANIFEST_SCHEMAS: Record<number, z.ZodType>;
+export { ArtifactRef, ConfigField, CoreScope, DescribedModule, dependenciesOf, Manifest, optionalDependenciesOf, REVERSE_DNS_ID, Storage, speaksCurrentSchema, } from './v2.ts';

package/types/registry/src/manifest/v2.d.ts

@@ -0,0 +1,182 @@
+import { z } from 'zod';
+/** One admin-configurable setting a module exposes. */
+export declare const ConfigField: z.ZodObject<{
+    key: z.ZodString;
+    label: z.ZodString;
+    type: z.ZodEnum<{
+        bool: "bool";
+        number: "number";
+        select: "select";
+        string: "string";
+    }>;
+    default: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    options: z.ZodOptional<z.ZodNullable<z.ZodArray<z.ZodString>>>;
+    placeholder: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    secret: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
+    required: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
+}, z.core.$strip>;
+export type ConfigField = z.infer<typeof ConfigField>;
+/** A module id: reverse-DNS, lowercase. */
+export declare const REVERSE_DNS_ID: RegExp;
+/** The slice of the SHARED core database a module may reach. */
+export declare const CoreScope: z.ZodObject<{
+    read: z.ZodOptional<z.ZodNullable<z.ZodArray<z.ZodString>>>;
+    write: z.ZodOptional<z.ZodNullable<z.ZodArray<z.ZodString>>>;
+}, z.core.$strip>;
+export type CoreScope = z.infer<typeof CoreScope>;
+/** A module's databases, and the capability itself. */
+export declare const Storage: z.ZodObject<{
+    core: z.ZodOptional<z.ZodNullable<z.ZodObject<{
+        read: z.ZodOptional<z.ZodNullable<z.ZodArray<z.ZodString>>>;
+        write: z.ZodOptional<z.ZodNullable<z.ZodArray<z.ZodString>>>;
+    }, z.core.$strip>>>;
+    adopt: z.ZodOptional<z.ZodNullable<z.ZodArray<z.ZodString>>>;
+}, z.core.$strip>;
+export type Storage = z.infer<typeof Storage>;
+/** A module's `module.json`, as authored. */
+export declare const Manifest: z.ZodObject<{
+    $schema: z.ZodOptional<z.ZodString>;
+    schemaVersion: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+    id: z.ZodString;
+    name: z.ZodString;
+    version: z.ZodString;
+    description: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    engines: z.ZodOptional<z.ZodNullable<z.ZodRecord<z.ZodString, z.ZodString>>>;
+    library: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
+    dependencies: z.ZodOptional<z.ZodNullable<z.ZodRecord<z.ZodString, z.ZodString>>>;
+    optionalDependencies: z.ZodOptional<z.ZodNullable<z.ZodRecord<z.ZodString, z.ZodString>>>;
+    definesPoints: z.ZodOptional<z.ZodNullable<z.ZodArray<z.ZodObject<{
+        name: z.ZodString;
+        version: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+        methods: z.ZodOptional<z.ZodNullable<z.ZodArray<z.ZodString>>>;
+    }, z.core.$catchall<z.ZodJSONSchema>>>>>;
+    contributes: z.ZodOptional<z.ZodNullable<z.ZodArray<z.ZodObject<{
+        point: z.ZodString;
+        version: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+        id: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    }, z.core.$catchall<z.ZodJSONSchema>>>>>;
+    consumes: z.ZodOptional<z.ZodNullable<z.ZodArray<z.ZodObject<{
+        point: z.ZodString;
+        version: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        id: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        optional: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
+    }, z.core.$catchall<z.ZodJSONSchema>>>>>;
+    config: z.ZodOptional<z.ZodNullable<z.ZodArray<z.ZodObject<{
+        key: z.ZodString;
+        label: z.ZodString;
+        type: z.ZodEnum<{
+            bool: "bool";
+            number: "number";
+            select: "select";
+            string: "string";
+        }>;
+        default: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        options: z.ZodOptional<z.ZodNullable<z.ZodArray<z.ZodString>>>;
+        placeholder: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        secret: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
+        required: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
+    }, z.core.$strip>>>>;
+    storage: z.ZodOptional<z.ZodNullable<z.ZodObject<{
+        core: z.ZodOptional<z.ZodNullable<z.ZodObject<{
+            read: z.ZodOptional<z.ZodNullable<z.ZodArray<z.ZodString>>>;
+            write: z.ZodOptional<z.ZodNullable<z.ZodArray<z.ZodString>>>;
+        }, z.core.$strip>>>;
+        adopt: z.ZodOptional<z.ZodNullable<z.ZodArray<z.ZodString>>>;
+    }, z.core.$strip>>>;
+    feRemote: z.ZodOptional<z.ZodNullable<z.ZodObject<{
+        module: z.ZodString;
+    }, z.core.$strip>>>;
+    author: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    homepage: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    license: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    keywords: z.ZodOptional<z.ZodNullable<z.ZodArray<z.ZodString>>>;
+    tags: z.ZodOptional<z.ZodNullable<z.ZodArray<z.ZodString>>>;
+}, z.core.$strip>;
+export type Manifest = z.infer<typeof Manifest>;
+/** Whether a module was built against the manifest contract this build speaks.
+ *  A bundle that was not is refused rather than read on a best-effort basis: the
+ *  fields that moved between versions parse as ABSENT, not as errors, so a stale
+ *  one would install with its dependencies silently dropped. */
+export declare function speaksCurrentSchema(manifest: Pick<Manifest, 'schemaVersion'>): boolean;
+/** The versions a module requires, by id. */
+export declare function dependenciesOf(manifest: Manifest): Record<string, string>;
+/** The versions a module suggests but does not require, by id. */
+export declare function optionalDependenciesOf(manifest: Manifest): Record<string, string>;
+/** What a registry document says about one downloadable build. */
+export declare const ArtifactRef: z.ZodObject<{
+    target: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    url: z.ZodString;
+    size: z.ZodNumber;
+    sha256: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    contentHash: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+}, z.core.$strip>;
+export type ArtifactRef = z.infer<typeof ArtifactRef>;
+/** The least a registry document can be built from: a manifest, an icon, and
+ *  the builds it ships. */
+export declare const DescribedModule: z.ZodObject<{
+    $schema: z.ZodOptional<z.ZodString>;
+    schemaVersion: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+    id: z.ZodString;
+    name: z.ZodString;
+    version: z.ZodString;
+    description: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    engines: z.ZodOptional<z.ZodNullable<z.ZodRecord<z.ZodString, z.ZodString>>>;
+    library: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
+    dependencies: z.ZodOptional<z.ZodNullable<z.ZodRecord<z.ZodString, z.ZodString>>>;
+    optionalDependencies: z.ZodOptional<z.ZodNullable<z.ZodRecord<z.ZodString, z.ZodString>>>;
+    definesPoints: z.ZodOptional<z.ZodNullable<z.ZodArray<z.ZodObject<{
+        name: z.ZodString;
+        version: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+        methods: z.ZodOptional<z.ZodNullable<z.ZodArray<z.ZodString>>>;
+    }, z.core.$catchall<z.ZodJSONSchema>>>>>;
+    contributes: z.ZodOptional<z.ZodNullable<z.ZodArray<z.ZodObject<{
+        point: z.ZodString;
+        version: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+        id: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    }, z.core.$catchall<z.ZodJSONSchema>>>>>;
+    consumes: z.ZodOptional<z.ZodNullable<z.ZodArray<z.ZodObject<{
+        point: z.ZodString;
+        version: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        id: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        optional: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
+    }, z.core.$catchall<z.ZodJSONSchema>>>>>;
+    config: z.ZodOptional<z.ZodNullable<z.ZodArray<z.ZodObject<{
+        key: z.ZodString;
+        label: z.ZodString;
+        type: z.ZodEnum<{
+            bool: "bool";
+            number: "number";
+            select: "select";
+            string: "string";
+        }>;
+        default: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        options: z.ZodOptional<z.ZodNullable<z.ZodArray<z.ZodString>>>;
+        placeholder: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        secret: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
+        required: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
+    }, z.core.$strip>>>>;
+    storage: z.ZodOptional<z.ZodNullable<z.ZodObject<{
+        core: z.ZodOptional<z.ZodNullable<z.ZodObject<{
+            read: z.ZodOptional<z.ZodNullable<z.ZodArray<z.ZodString>>>;
+            write: z.ZodOptional<z.ZodNullable<z.ZodArray<z.ZodString>>>;
+        }, z.core.$strip>>>;
+        adopt: z.ZodOptional<z.ZodNullable<z.ZodArray<z.ZodString>>>;
+    }, z.core.$strip>>>;
+    feRemote: z.ZodOptional<z.ZodNullable<z.ZodObject<{
+        module: z.ZodString;
+    }, z.core.$strip>>>;
+    author: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    homepage: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    license: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    keywords: z.ZodOptional<z.ZodNullable<z.ZodArray<z.ZodString>>>;
+    tags: z.ZodOptional<z.ZodNullable<z.ZodArray<z.ZodString>>>;
+    icon: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    artifacts: z.ZodArray<z.ZodObject<{
+        target: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        url: z.ZodString;
+        size: z.ZodNumber;
+        sha256: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        contentHash: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+export type DescribedModule = z.infer<typeof DescribedModule>;

package/types/registry/src/semver.d.ts

@@ -0,0 +1,24 @@
+export interface Version {
+    major: number;
+    minor: number;
+    patch: number;
+    prerelease: (string | number)[];
+}
+/** `null` when `raw` is not a version this pipeline will publish. */
+export declare function parse(raw: string): Version | null;
+/** Compares two raw strings; unparseable ones sort below anything valid. */
+export declare function compareRaw(a: string, b: string): number;
+/**
+ * Whether `version` is inside `range`, for the operators the manifests use
+ * (exact, `^`, `~`, `>=`, `*`). Pre-releases stay opt-in exactly as npm has
+ * them: `^0.1.0` never matches `0.2.0-beta.1`, and a pre-release only satisfies
+ * a range whose own comparator is a pre-release of the same `x.y.z`. An
+ * unparseable version or comparator satisfies nothing.
+ */
+export declare function satisfies(version: string, range: string): boolean;
+/**
+ * The named channel a version belongs to: `latest` for a stable release, its
+ * first pre-release identifier (`beta`, `rc`, `nightly`…) otherwise, and `null`
+ * for a pre-release that names none (`1.0.0-1`) or a version that is not semver.
+ */
+export declare function channelOf(version: string): string | null;

package/types/registry/src/sort.d.ts

@@ -0,0 +1,2 @@
+/** Compares by UTF-16 code unit - the machine-independent ordering. */
+export declare function byCodeUnit(a: string, b: string): number;

package/types/registry/src/spec.d.ts

@@ -0,0 +1,19 @@
+/** The document names a conforming registry serves a schema for. */
+export type SchemaName = 'manifest' | 'registry' | 'index' | 'module';
+export declare const SCHEMA_NAMES: SchemaName[];
+/** Which version of its contract a document currently belongs to. The manifest
+ *  and the served documents version independently. */
+export declare const schemaVersionOf: (name: SchemaName) => number;
+/** Where a schema is published: `/schemas/<version>/<name>.json`, the shape
+ *  Biome and json-schema.org already use (and that this repo already pins
+ *  against in `biome.json`). Versioned, so a later contract is a NEW document
+ *  rather than a silent edit to the one third parties pinned against. */
+export declare const schemaPath: (name: SchemaName, version?: number) => string;
+/** Whether this build still publishes that version of that document. */
+export declare const publishesSchema: (name: SchemaName, version: number) => boolean;
+/** A JSON Schema document. */
+export type JsonSchema = Record<string, unknown>;
+/** The JSON Schema (draft 2020-12) for one version of one document, or `null`
+ *  when this build does not publish that version. `origin` makes `$id` the URL
+ *  it is actually served from. */
+export declare function jsonSchema(name: SchemaName, version?: number, origin?: string): JsonSchema | null;

package/types/registry/src/text.d.ts

@@ -0,0 +1,6 @@
+/** Bytes as base64. `fromCodePoint` over `fromCharCode`: both are exact for the
+ *  0..255 range these carry, and only one of them is the one to reach for. */
+export declare function base64(bytes: Uint8Array): string;
+/** A URL path or base with its trailing slashes removed. A loop rather than
+ *  `/\/+$/`, which backtracks super-linearly on a long run of slashes. */
+export declare function trimTrailingSlashes(value: string): string;

package/types/spatial-nav/src/descent.d.ts

@@ -0,0 +1,9 @@
+import type { FocusTree, TreeNode } from './focus-tree';
+/** The focusable node `node` stands for: itself when it is focusable, else the
+ *  child it was last left on, else its first focusable descendant. */
+export declare function focusableIn(tree: FocusTree, node: TreeNode): TreeNode | null;
+export declare function firstAmong(tree: FocusTree, nodes: readonly TreeNode[]): TreeNode | null;
+export declare function firstFocusable(tree: FocusTree): TreeNode | null;
+/** Enters `node` at the column an aligned grid is walking, falling back to the
+ *  nearest lower index and then to whatever the container itself prefers. */
+export declare function alignedIn(tree: FocusTree, node: TreeNode, column: number): TreeNode | null;

package/types/spatial-nav/src/directions.d.ts

@@ -0,0 +1,16 @@
+export declare const Directions: {
+    readonly LEFT: 'left';
+    readonly RIGHT: 'right';
+    readonly UP: 'up';
+    readonly DOWN: 'down';
+    readonly ENTER: 'enter';
+};
+export type Direction = (typeof Directions)[keyof typeof Directions];
+export type Orientation = 'horizontal' | 'vertical';
+export interface Move {
+    readonly orientation: Orientation;
+    readonly forward: boolean;
+}
+/** The axis and the sense a direction walks a container in; null for `enter`,
+ *  which moves nothing. */
+export declare function moveOf(direction: Direction): Move | null;

package/types/spatial-nav/src/fallback-focus.d.ts

@@ -0,0 +1,5 @@
+import type { FocusTree, TreeNode } from './focus-tree';
+/** Where the focus goes when `node`'s subtree leaves the tree: the sibling
+ *  before it, else the one after it, else the same search one level up. Call it
+ *  while the subtree is still attached; it never returns a node inside it. */
+export declare function fallbackFocus(tree: FocusTree, node: TreeNode): TreeNode | null;

package/types/spatial-nav/src/focus-owner.d.ts

@@ -0,0 +1,16 @@
+import type { FocusTree, TreeNode } from './focus-tree';
+/** The one node holding the focus, and the branch of containers above it. Every
+ *  move blurs before it focuses; a move onto another branch also deactivates the
+ *  branch it left and activates the one it entered, down to and including the
+ *  node taking the focus. A move between siblings is the focus alone, and losing
+ *  the focus entirely deactivates nothing. */
+export declare class FocusOwner {
+    private readonly tree;
+    private focused;
+    private branch;
+    constructor(tree: FocusTree);
+    get focusedNode(): TreeNode | null;
+    move(next: TreeNode | null): void;
+    private branchOf;
+    private notify;
+}

package/types/spatial-nav/src/focus-tree.d.ts

@@ -0,0 +1,63 @@
+import type { Orientation } from './directions';
+/** What a node declares when it registers. `index` is its slot among its
+ *  siblings: omitted, the node lands after the highest index its parent has
+ *  handed out, and a tie is broken by registration order. */
+export interface NodeConfig {
+    parent?: string;
+    index?: number;
+    focusable?: boolean;
+    orientation?: Orientation;
+    alignInGrid?: boolean;
+    onFocus?: () => void;
+    onBlur?: () => void;
+    onActive?: () => void;
+    onInactive?: () => void;
+    onSelect?: () => void;
+}
+export interface TreeNode {
+    readonly id: string;
+    readonly parent: string | null;
+    readonly index: number;
+    readonly seq: number;
+    readonly focusable: boolean;
+    readonly orientation: Orientation | null;
+    readonly alignInGrid: boolean;
+    readonly config: NodeConfig;
+    activeChild: string | null;
+}
+export interface Siblings {
+    readonly before: readonly TreeNode[];
+    readonly after: readonly TreeNode[];
+}
+/** The tree the navigator walks: who is whose child, in what order, and which
+ *  child each container was last left on. Registering an id it already holds,
+ *  or dropping one it does not, is a no-op, and a node whose parent has not
+ *  registered yet is held until it does. */
+export declare class FocusTree {
+    private readonly nodes;
+    private readonly children;
+    private readonly waiting;
+    private readonly slots;
+    private sequence;
+    get(id: string): TreeNode | undefined;
+    childrenOf(parent: string | null): readonly TreeNode[];
+    /** The node `id` names, but only once every parent between it and a root has
+     *  registered. */
+    reachable(id: string): TreeNode | undefined;
+    register(id: string, config: NodeConfig): void;
+    remove(node: TreeNode): void;
+    /** `node`'s ancestors, nearest first. */
+    ancestorsOf(node: TreeNode): TreeNode[];
+    contains(ancestor: TreeNode, node: TreeNode): boolean;
+    /** `node`'s siblings on each side of it, nearest first. */
+    siblingsAround(node: TreeNode): Siblings;
+    /** The child `node` was last left on, while it is still one of its children. */
+    activeChildOf(node: TreeNode): TreeNode | undefined;
+    remember(node: TreeNode): void;
+    private parentOf;
+    private link;
+    private unlink;
+    private hold;
+    private attachHeld;
+    private subtree;
+}

package/types/spatial-nav/src/index.d.ts

@@ -0,0 +1,4 @@
+export type { Direction, Orientation } from './directions';
+export { Directions } from './directions';
+export type { NodeConfig } from './focus-tree';
+export { SpatialNavigator } from './spatial-navigator';

package/types/spatial-nav/src/navigator.bench.d.ts

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

package/types/spatial-nav/src/react/configure-remote.d.ts

@@ -0,0 +1,16 @@
+import type { Direction } from '@kroma/spatial-nav';
+type RemoteHandler = (direction: Direction) => void;
+type Unsubscribe = () => void;
+interface RemoteConfig {
+    subscribe: (handle: RemoteHandler) => Unsubscribe;
+}
+/**
+ * Names the transport every `<NavigatorRoot>` hears the remote through: one
+ * process, one set of keys, however many navigators are mounted. Call it once
+ * at startup, before the first root renders; a root that mounts first never
+ * subscribes.
+ */
+declare function configureRemote({ subscribe }: RemoteConfig): void;
+declare function subscribeRemote(handle: RemoteHandler): Unsubscribe;
+export type { RemoteConfig, RemoteHandler };
+export { configureRemote, subscribeRemote };

package/types/spatial-nav/src/react/default-focus.d.ts

@@ -0,0 +1,15 @@
+import { type ReactNode } from 'react';
+interface DefaultFocusProps {
+    children: ReactNode;
+    /** Default true, so the marker can be left in place and switched off. */
+    enable?: boolean;
+}
+/**
+ * Where the focus opens. Every focusable descendant claims it as it mounts and
+ * the first claim wins; a claim made before the tree is registered is held
+ * until it is, and one made after something else took the focus is dropped.
+ */
+declare function DefaultFocus({ children, enable }: Readonly<DefaultFocusProps>): import("react").JSX.Element;
+declare function useDefaultFocus(): boolean;
+export type { DefaultFocusProps };
+export { DefaultFocus, useDefaultFocus };