nirs4all 0.2.8 → 0.2.9

package/README.md

@@ -25,6 +25,12 @@ Savitzky-Golay defaults to `mode: "interp"` for full nirs4all parity and
 preserves explicit methods-backed modes (`mirror`, `constant`, `nearest`,
 `wrap`, `interp`) plus `cval` in the serialized preprocessing chain.
 
+Custom app hosts can inspect `capabilityManifest()`, `controllerCapabilities`,
+and `runtimeSurfaces` before rendering graph nodes or selecting a runtime. The
+manifest schema is `nirs4all-core.capabilities.v1`; it exposes the stable V1
+controller IDs for Kennard-Stone, SNV, Savitzky-Golay, PLS regression, and the
+portable methods pipeline, with parameter lists matching the executable parser.
+
 For a browser-only custom host, pair this package with `nirs4all-ui`: keep
 runtime loading and portable execution in `nirs4all`, and consume shared React
 components / view-model helpers / brand assets from `nirs4all-ui`. The

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "nirs4all",
-  "version": "0.2.8",
+  "version": "0.2.9",
   "description": "Portable nirs4all aggregate binding for JavaScript and WASM",
   "type": "module",
   "exports": {

package/src/index.d.ts

@@ -16,6 +16,33 @@ export interface PipelineDefinition {
   pipeline: unknown[];
 }
 
+export type RuntimeSurface = 'python' | 'r' | 'javascript_wasm' | 'rust' | 'matlab_octave';
+export type CapabilityLevel = 'metadata' | 'plan' | 'execute-local' | 'execute-remote' | 'parity-validated';
+
+export interface ControllerCapability {
+  id: string;
+  kind: 'splitter' | 'transform' | 'model' | 'pipeline';
+  domain: Upstream['key'];
+  label: string;
+  operatorClasses: readonly string[];
+  ports: {
+    inputs: readonly string[];
+    outputs: readonly string[];
+  };
+  parameters: readonly string[];
+  runtime: Readonly<Record<RuntimeSurface, CapabilityLevel>>;
+  executionPath: 'portable_pipeline' | 'run_portable_pipeline';
+  composes?: readonly string[];
+}
+
+export interface CapabilityManifest {
+  schema: 'nirs4all-core.capabilities.v1';
+  aggregate: 'nirs4all-core';
+  runtimeSurfaces: readonly RuntimeSurface[];
+  portableOperatorClasses: readonly string[];
+  controllers: readonly ControllerCapability[];
+}
+
 export interface PortableMatrixDataset {
   X: Float64Array | number[] | readonly number[] | readonly (readonly number[])[];
   y: Float64Array | number[] | readonly number[] | readonly (readonly number[])[];
@@ -68,6 +95,9 @@ export interface PortablePredictionResult {
 
 export const upstreams: readonly Upstream[];
 export const portableOperatorClasses: readonly string[];
+export const runtimeSurfaces: readonly RuntimeSurface[];
+export const controllerCapabilities: readonly ControllerCapability[];
+export function capabilityManifest(): CapabilityManifest;
 
 export function upstream(name: string): Upstream | null;
 export function importUpstream(name: string): Promise<unknown>;

package/src/index.js

@@ -45,6 +45,120 @@ export const portableOperatorClasses = Object.freeze([
   'sklearn.cross_decomposition._pls.PLSRegression',
 ]);
 
+export const runtimeSurfaces = Object.freeze([
+  'python',
+  'r',
+  'javascript_wasm',
+  'rust',
+  'matlab_octave',
+]);
+
+const parityRuntime = Object.freeze(Object.fromEntries(
+  runtimeSurfaces.map((surface) => [surface, 'parity-validated']),
+));
+
+export const controllerCapabilities = Object.freeze([
+  Object.freeze({
+    id: 'split.kennard_stone',
+    kind: 'splitter',
+    domain: 'methods',
+    label: 'Kennard-Stone split',
+    operatorClasses: Object.freeze([
+      'nirs4all.operators.splitters.KennardStoneSplitter',
+      'nirs4all.operators.splitters.splitters.KennardStoneSplitter',
+    ]),
+    ports: Object.freeze({
+      inputs: Object.freeze(['X']),
+      outputs: Object.freeze(['train_indices', 'test_indices']),
+    }),
+    parameters: Object.freeze(['test_size']),
+    runtime: parityRuntime,
+    executionPath: 'portable_pipeline',
+  }),
+  Object.freeze({
+    id: 'preprocess.snv',
+    kind: 'transform',
+    domain: 'methods',
+    label: 'Standard normal variate',
+    operatorClasses: Object.freeze([
+      'nirs4all.operators.transforms.SNV',
+      'nirs4all.operators.transforms.StandardNormalVariate',
+      'nirs4all.operators.transforms.scalers.StandardNormalVariate',
+    ]),
+    ports: Object.freeze({
+      inputs: Object.freeze(['X']),
+      outputs: Object.freeze(['X_transformed']),
+    }),
+    parameters: Object.freeze([]),
+    runtime: parityRuntime,
+    executionPath: 'portable_pipeline',
+  }),
+  Object.freeze({
+    id: 'preprocess.savgol',
+    kind: 'transform',
+    domain: 'methods',
+    label: 'Savitzky-Golay',
+    operatorClasses: Object.freeze([
+      'nirs4all.operators.transforms.SavitzkyGolay',
+      'nirs4all.operators.transforms.nirs.SavitzkyGolay',
+    ]),
+    ports: Object.freeze({
+      inputs: Object.freeze(['X']),
+      outputs: Object.freeze(['X_transformed']),
+    }),
+    parameters: Object.freeze(['window_length', 'polyorder', 'deriv', 'mode', 'cval']),
+    runtime: parityRuntime,
+    executionPath: 'portable_pipeline',
+  }),
+  Object.freeze({
+    id: 'model.pls_regression',
+    kind: 'model',
+    domain: 'methods',
+    label: 'PLS regression',
+    operatorClasses: Object.freeze([
+      'sklearn.cross_decomposition.PLSRegression',
+      'sklearn.cross_decomposition._pls.PLSRegression',
+    ]),
+    ports: Object.freeze({
+      inputs: Object.freeze(['X', 'y']),
+      outputs: Object.freeze(['predictions', 'model']),
+    }),
+    parameters: Object.freeze(['n_components', '_range_']),
+    runtime: parityRuntime,
+    executionPath: 'portable_pipeline',
+  }),
+  Object.freeze({
+    id: 'pipeline.portable_methods',
+    kind: 'pipeline',
+    domain: 'methods',
+    label: 'Portable methods pipeline',
+    operatorClasses: Object.freeze([]),
+    ports: Object.freeze({
+      inputs: Object.freeze(['pipeline', 'dataset']),
+      outputs: Object.freeze(['execution_result', 'predictions', 'model']),
+    }),
+    parameters: Object.freeze([]),
+    runtime: parityRuntime,
+    executionPath: 'run_portable_pipeline',
+    composes: Object.freeze([
+      'split.kennard_stone',
+      'preprocess.snv',
+      'preprocess.savgol',
+      'model.pls_regression',
+    ]),
+  }),
+]);
+
+export function capabilityManifest() {
+  return clone({
+    schema: 'nirs4all-core.capabilities.v1',
+    aggregate: 'nirs4all-core',
+    runtimeSurfaces,
+    portableOperatorClasses,
+    controllers: controllerCapabilities,
+  });
+}
+
 const portableOperatorSet = new Set(portableOperatorClasses);
 
 const upstreamByKey = new Map(upstreams.map((item) => [item.key, item]));