nirs4all 0.2.7 → 0.2.9

package/README.md

@@ -11,7 +11,7 @@ application lives in `nirs4all-web`; this directory is for the reusable
 JavaScript/WASM binding and package metadata.
 
 The portable execution API delegates Kennard-Stone, SNV, Savitzky-Golay, and
-PLS component sweeps to `@nirs4all/methods-wasm`:
+PLS component sweeps to `@nirs4all/methods`:
 
 - `runPortablePipeline(source, dataset)` parses the shared nirs4all JSON/YAML
   syntax, executes the portable subset, and returns parity-checkable split,
@@ -24,3 +24,16 @@ PLS component sweeps to `@nirs4all/methods-wasm`:
 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
+reference composition lives in `../../nirs4all-web/studio-lite`, whose contract
+tests exercise `runPortablePipeline()` / `predictPortablePipeline()` together
+with the shared UI package in a no-backend environment.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "nirs4all",
-  "version": "0.2.7",
+  "version": "0.2.9",
   "description": "Portable nirs4all aggregate binding for JavaScript and WASM",
   "type": "module",
   "exports": {
@@ -47,7 +47,7 @@
     "@nirs4all/datasets-wasm": "*",
     "@nirs4all/formats-wasm": "*",
     "@nirs4all/io-wasm": "*",
-    "@nirs4all/methods-wasm": "*",
+    "@nirs4all/methods": "*",
     "@nirs4all/nirs4all-datasets-wasm": "*",
     "dag-ml-data-wasm": "*",
     "dag-ml-wasm": "*",
@@ -64,7 +64,7 @@
     "@nirs4all/io-wasm": {
       "optional": true
     },
-    "@nirs4all/methods-wasm": {
+    "@nirs4all/methods": {
       "optional": true
     },
     "@nirs4all/nirs4all-datasets-wasm": {
@@ -82,5 +82,9 @@
     "dag-ml-data-wasm": {
       "optional": true
     }
+  },
+  "publishConfig": {
+    "access": "public",
+    "provenance": true
   }
 }

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

@@ -28,7 +28,7 @@ export const upstreams = Object.freeze([
   },
   {
     key: 'methods',
-    candidates: ['@nirs4all/methods-wasm'],
+    candidates: ['@nirs4all/methods'],
     role: 'Portable C ABI PLS/NIRS numerical engine',
   },
 ]);
@@ -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]));
@@ -213,8 +327,8 @@ function importUpstreamCandidate(candidate) {
       return import('@nirs4all/datasets-wasm');
     case '@nirs4all/nirs4all-datasets-wasm':
       return import('@nirs4all/nirs4all-datasets-wasm');
-    case '@nirs4all/methods-wasm':
-      return import('@nirs4all/methods-wasm');
+    case '@nirs4all/methods':
+      return import('@nirs4all/methods');
     default:
       return import(candidate);
   }