@workglow/util 0.0.84 → 0.0.86

package/README.md

@@ -108,6 +108,37 @@ container.register("UserService", UserService);
 const userService = container.resolve<UserService>("UserService");
 ```
 
+### Input Resolver Registry
+
+The input resolver registry enables automatic resolution of string identifiers to object instances based on JSON Schema format annotations. This is used by the TaskRunner to resolve inputs like model names or repository IDs before task execution.
+
+```typescript
+import {
+  registerInputResolver,
+  getInputResolvers,
+  INPUT_RESOLVERS,
+} from "@workglow/util";
+
+// Register a custom resolver for a format prefix
+registerInputResolver("myformat", async (id, format, registry) => {
+  // id: the string value to resolve (e.g., "my-item-id")
+  // format: the full format string (e.g., "myformat:subtype")
+  // registry: ServiceRegistry for accessing other services
+
+  const myRepo = registry.get(MY_REPOSITORY_TOKEN);
+  const item = await myRepo.findById(id);
+  if (!item) {
+    throw new Error(`Item "${id}" not found`);
+  }
+  return item;
+});
+
+// Get all registered resolvers
+const resolvers = getInputResolvers();
+```
+
+When a task input schema includes a property with `format: "myformat:subtype"`, and the input value is a string, the resolver is called automatically to convert it to the resolved instance.
+
 ### Event System
 
 ```typescript
@@ -260,6 +291,7 @@ type User = z.infer<typeof userSchemaZod>;
 - Decorator-based injection
 - Singleton and transient lifetimes
 - Circular dependency detection
+- Input resolver registry for schema-based resolution
 
 ### Event System (`/events`)
 

package/dist/browser.js

@@ -77,6 +77,19 @@ class ServiceRegistry {
   }
 }
 var globalServiceRegistry = new ServiceRegistry(globalContainer);
+
+// src/di/InputResolverRegistry.ts
+var INPUT_RESOLVERS = createServiceToken("task.input.resolvers");
+if (!globalServiceRegistry.has(INPUT_RESOLVERS)) {
+  globalServiceRegistry.register(INPUT_RESOLVERS, () => new Map, true);
+}
+function getInputResolvers() {
+  return globalServiceRegistry.get(INPUT_RESOLVERS);
+}
+function registerInputResolver(formatPrefix, resolver) {
+  const resolvers = getInputResolvers();
+  resolvers.set(formatPrefix, resolver);
+}
 // src/events/EventEmitter.ts
 class EventEmitter {
   listeners = {};
@@ -963,7 +976,7 @@ function areObjectSchemasSemanticallyCompatible(sourceSchema, targetSchema) {
   return areSemanticallyCompatible(sourceSchema, targetSchema);
 }
 // src/json-schema/SchemaValidation.ts
-import { compileSchema } from "json-schema-library";
+import { compileSchema } from "@sroussey/json-schema-library";
 // src/utilities/Misc.ts
 function forceArray(input) {
   if (Array.isArray(input))
@@ -1337,6 +1350,208 @@ function objectOfArraysAsArrayOfObjects(data) {
     }
   });
 }
+// src/vector/TypedArray.ts
+function isTypedArray(value) {
+  return ArrayBuffer.isView(value) && !(value instanceof DataView);
+}
+var TypedArrayType = null;
+var TypedArraySchemaOptions = {
+  ...FromSchemaDefaultOptions,
+  deserialize: [
+    {
+      pattern: { type: "array", format: "TypedArray:Float64Array" },
+      output: Float64Array
+    },
+    {
+      pattern: { type: "array", format: "TypedArray:Float32Array" },
+      output: Float32Array
+    },
+    {
+      pattern: { type: "array", format: "TypedArray:Float16Array" },
+      output: Float16Array
+    },
+    {
+      pattern: { type: "array", format: "TypedArray:Int16Array" },
+      output: Int16Array
+    },
+    {
+      pattern: { type: "array", format: "TypedArray:Int8Array" },
+      output: Int8Array
+    },
+    {
+      pattern: { type: "array", format: "TypedArray:Uint8Array" },
+      output: Uint8Array
+    },
+    {
+      pattern: { type: "array", format: "TypedArray:Uint16Array" },
+      output: Uint16Array
+    },
+    {
+      pattern: { type: "array", format: "TypedArray" },
+      output: TypedArrayType
+    }
+  ]
+};
+var TypedArraySchema = (annotations = {}) => {
+  return {
+    type: "array",
+    format: "TypedArray",
+    title: "Typed Array",
+    description: "A typed array (Float32Array, Int8Array, etc.)",
+    ...annotations
+  };
+};
+
+// src/vector/Tensor.ts
+var TensorType = {
+  FLOAT16: "float16",
+  FLOAT32: "float32",
+  FLOAT64: "float64",
+  INT8: "int8",
+  UINT8: "uint8",
+  INT16: "int16",
+  UINT16: "uint16"
+};
+var TensorSchema = (annotations = {}) => ({
+  type: "object",
+  properties: {
+    type: {
+      type: "string",
+      enum: Object.values(TensorType),
+      title: "Type",
+      description: "The type of the tensor"
+    },
+    data: TypedArraySchema({
+      title: "Data",
+      description: "The data of the tensor"
+    }),
+    shape: {
+      type: "array",
+      items: { type: "number" },
+      title: "Shape",
+      description: "The shape of the tensor (dimensions)",
+      minItems: 1,
+      default: [1]
+    },
+    normalized: {
+      type: "boolean",
+      title: "Normalized",
+      description: "Whether the tensor data is normalized",
+      default: false
+    }
+  },
+  required: ["data"],
+  additionalProperties: false,
+  ...annotations
+});
+// src/vector/VectorSimilarityUtils.ts
+function cosineSimilarity(a, b) {
+  if (a.length !== b.length) {
+    throw new Error("Vectors must have the same length");
+  }
+  let dotProduct = 0;
+  let normA = 0;
+  let normB = 0;
+  for (let i = 0;i < a.length; i++) {
+    dotProduct += a[i] * b[i];
+    normA += a[i] * a[i];
+    normB += b[i] * b[i];
+  }
+  const denominator = Math.sqrt(normA) * Math.sqrt(normB);
+  if (denominator === 0) {
+    return 0;
+  }
+  return dotProduct / denominator;
+}
+function jaccardSimilarity(a, b) {
+  if (a.length !== b.length) {
+    throw new Error("Vectors must have the same length");
+  }
+  let globalMin = a[0];
+  for (let i = 0;i < a.length; i++) {
+    globalMin = Math.min(globalMin, a[i], b[i]);
+  }
+  const shift = globalMin < 0 ? -globalMin : 0;
+  let minSum = 0;
+  let maxSum = 0;
+  for (let i = 0;i < a.length; i++) {
+    const shiftedA = a[i] + shift;
+    const shiftedB = b[i] + shift;
+    minSum += Math.min(shiftedA, shiftedB);
+    maxSum += Math.max(shiftedA, shiftedB);
+  }
+  return maxSum === 0 ? 0 : minSum / maxSum;
+}
+function hammingDistance(a, b) {
+  if (a.length !== b.length) {
+    throw new Error("Vectors must have the same length");
+  }
+  let differences = 0;
+  for (let i = 0;i < a.length; i++) {
+    if (a[i] !== b[i]) {
+      differences++;
+    }
+  }
+  return differences / a.length;
+}
+function hammingSimilarity(a, b) {
+  return 1 - hammingDistance(a, b);
+}
+// src/vector/VectorUtils.ts
+function magnitude(arr) {
+  return Math.sqrt(arr.reduce((acc, val) => acc + val * val, 0));
+}
+function inner(arr1, arr2) {
+  if (arr1.length !== arr2.length) {
+    throw new Error("Vectors must have the same length to compute inner product.");
+  }
+  return arr1.reduce((acc, val, i) => acc + val * arr2[i], 0);
+}
+function normalize(vector, throwOnZero = true, float32 = false) {
+  const mag = magnitude(vector);
+  if (mag === 0) {
+    if (throwOnZero) {
+      throw new Error("Cannot normalize a zero vector.");
+    }
+    return vector;
+  }
+  const normalized = Array.from(vector).map((val) => Number(val) / mag);
+  if (float32) {
+    return new Float32Array(normalized);
+  }
+  if (vector instanceof Float64Array) {
+    return new Float64Array(normalized);
+  }
+  if (vector instanceof Float16Array) {
+    return new Float16Array(normalized);
+  }
+  if (vector instanceof Float32Array) {
+    return new Float32Array(normalized);
+  }
+  if (vector instanceof Int8Array) {
+    return new Int8Array(normalized);
+  }
+  if (vector instanceof Uint8Array) {
+    return new Uint8Array(normalized);
+  }
+  if (vector instanceof Int16Array) {
+    return new Int16Array(normalized);
+  }
+  if (vector instanceof Uint16Array) {
+    return new Uint16Array(normalized);
+  }
+  return new Float32Array(normalized);
+}
+function normalizeNumberArray(values, throwOnZero = false) {
+  const norm = magnitude(values);
+  if (norm === 0) {
+    if (throwOnZero) {
+      throw new Error("Cannot normalize a zero vector.");
+    }
+    return values;
+  }
+  return values.map((v) => v / norm);
+}
 // src/worker/WorkerManager.ts
 function extractTransferables(obj) {
   const transferables = [];
@@ -1661,16 +1876,27 @@ export {
   sleep,
   sha256,
   serialize,
+  registerInputResolver,
   parseDataUri,
   parentPort2 as parentPort,
   objectOfArraysAsArrayOfObjects,
+  normalizeNumberArray,
+  normalize,
   makeFingerprint,
+  magnitude,
+  jaccardSimilarity,
+  isTypedArray,
+  inner,
+  hammingSimilarity,
+  hammingDistance,
   globalServiceRegistry,
   globalContainer,
+  getInputResolvers,
   forceArray,
   deepEqual,
   decompress,
   createServiceToken,
+  cosineSimilarity,
   convertImageDataToUseableForm,
   compress,
   compileSchema,
@@ -1682,9 +1908,13 @@ export {
   Worker,
   WORKER_SERVER,
   WORKER_MANAGER,
+  TypedArraySchema,
+  TensorType,
+  TensorSchema,
   ServiceRegistry,
   NodeDoesntExistError,
   NodeAlreadyExistsError,
+  INPUT_RESOLVERS,
   Graph,
   FromSchemaDefaultOptions,
   EventEmitter,
@@ -1695,4 +1925,4 @@ export {
   BaseError
 };
 
-//# debugId=DCF1ADC7882ABF2964756E2164756E21
+//# debugId=98769FE9D055D7AC64756E2164756E21