@graphorin/core 0.5.0

package/dist/utils/streams.js

@@ -0,0 +1,169 @@
+//#region src/utils/streams.ts
+/**
+* Stream / async-iterable helpers. All helpers honor `AbortSignal`
+* propagation: when the supplied signal aborts, the underlying
+* iterator's `return()` method is invoked so that resources held by the
+* upstream generator are released cleanly.
+*
+* @packageDocumentation
+*/
+/**
+* Internal helper: detect whether `it` already has its own
+* `AsyncIterator.return` so we know whether to forward cancellations.
+*/
+function hasReturn(iter) {
+	return typeof iter.return === "function";
+}
+/**
+* Drain an `AsyncIterable` into an array.
+*
+* @stable
+*/
+async function collect(source, signal) {
+	const out = [];
+	for await (const item of withSignal(source, signal)) out.push(item);
+	return out;
+}
+/**
+* Map every value of an async iterable. The mapper may be async.
+* Cancellation via `signal` is honored.
+*
+* @stable
+*/
+async function* mapStream(source, fn, signal) {
+	let index = 0;
+	for await (const item of withSignal(source, signal)) yield await fn(item, index++);
+}
+/**
+* Filter values produced by `source`. The predicate may be async.
+*
+* @stable
+*/
+async function* filter(source, pred, signal) {
+	let index = 0;
+	for await (const item of withSignal(source, signal)) if (await pred(item, index++)) yield item;
+}
+/**
+* Take the first `n` items.
+*
+* @stable
+*/
+async function* take(source, n, signal) {
+	if (n <= 0) return;
+	let i = 0;
+	for await (const item of withSignal(source, signal)) {
+		yield item;
+		if (++i >= n) return;
+	}
+}
+/**
+* Take items as long as `pred` returns truthy. The first item for which
+* `pred` returns falsy ends the stream.
+*
+* @stable
+*/
+async function* takeWhile(source, pred, signal) {
+	let index = 0;
+	for await (const item of withSignal(source, signal)) {
+		if (!await pred(item, index++)) return;
+		yield item;
+	}
+}
+/**
+* Merge multiple async iterables into a single output iterable. Items
+* are yielded in the order they arrive (interleaved), not in source
+* order. Cancellation propagates to every upstream iterator.
+*
+* @stable
+*/
+async function* merge(sources, signal) {
+	if (sources.length === 0) return;
+	const pending = sources.map((s) => s[Symbol.asyncIterator]()).map((iter, index) => ({
+		iter,
+		index,
+		promise: iter.next()
+	}));
+	const onAbort = async () => {
+		await Promise.all(pending.map(async (p) => {
+			if (p && hasReturn(p.iter)) try {
+				await p.iter.return(void 0);
+			} catch {}
+		}));
+	};
+	if (signal?.aborted) {
+		await onAbort();
+		return;
+	}
+	const abortListener = () => {
+		onAbort();
+	};
+	signal?.addEventListener("abort", abortListener, { once: true });
+	try {
+		while (pending.some((p) => p !== null)) {
+			if (signal?.aborted) return;
+			const live = pending.filter((p) => p !== null);
+			const winner = await Promise.race(live.map(async (p) => ({
+				p,
+				result: await p.promise
+			})));
+			if (winner.result.done) {
+				pending[winner.p.index] = null;
+				continue;
+			}
+			yield winner.result.value;
+			pending[winner.p.index] = {
+				...winner.p,
+				promise: winner.p.iter.next()
+			};
+		}
+	} finally {
+		signal?.removeEventListener("abort", abortListener);
+		await Promise.all(pending.map(async (p) => {
+			if (p && hasReturn(p.iter)) try {
+				await p.iter.return(void 0);
+			} catch {}
+		}));
+	}
+}
+/**
+* Wrap `source` with abort-signal propagation: when `signal` aborts the
+* underlying iterator's `return()` is called and the loop exits cleanly.
+*
+* @stable
+*/
+async function* withSignal(source, signal) {
+	if (!signal) {
+		yield* source;
+		return;
+	}
+	if (signal.aborted) return;
+	const iter = source[Symbol.asyncIterator]();
+	let abortListener = null;
+	const abortPromise = new Promise((resolve) => {
+		abortListener = () => resolve({ aborted: true });
+		signal.addEventListener("abort", abortListener, { once: true });
+	});
+	try {
+		while (true) {
+			const next = iter.next();
+			const winner = await Promise.race([next.then((r) => ({
+				aborted: false,
+				result: r
+			})), abortPromise]);
+			if (winner.aborted) {
+				if (hasReturn(iter)) try {
+					await iter.return(void 0);
+				} catch {}
+				return;
+			}
+			if (winner.result.done) return;
+			yield winner.result.value;
+		}
+	} finally {
+		if (abortListener) signal.removeEventListener("abort", abortListener);
+	}
+}
+
+//#endregion
+export { collect, filter, mapStream, merge, take, takeWhile, withSignal };
+//# sourceMappingURL=streams.js.map

package/dist/utils/streams.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"streams.js","names":["out: T[]","pending: Array<Pending | null>","abortListener: (() => void) | null"],"sources":["../../src/utils/streams.ts"],"sourcesContent":["/**\n * Stream / async-iterable helpers. All helpers honor `AbortSignal`\n * propagation: when the supplied signal aborts, the underlying\n * iterator's `return()` method is invoked so that resources held by the\n * upstream generator are released cleanly.\n *\n * @packageDocumentation\n */\n\n/**\n * Internal helper: detect whether `it` already has its own\n * `AsyncIterator.return` so we know whether to forward cancellations.\n */\nfunction hasReturn<T>(\n  iter: AsyncIterator<T>,\n): iter is AsyncIterator<T> & { return: NonNullable<AsyncIterator<T>['return']> } {\n  return typeof iter.return === 'function';\n}\n\n/**\n * Drain an `AsyncIterable` into an array.\n *\n * @stable\n */\nexport async function collect<T>(source: AsyncIterable<T>, signal?: AbortSignal): Promise<T[]> {\n  const out: T[] = [];\n  for await (const item of withSignal(source, signal)) {\n    out.push(item);\n  }\n  return out;\n}\n\n/**\n * Map every value of an async iterable. The mapper may be async.\n * Cancellation via `signal` is honored.\n *\n * @stable\n */\nexport async function* mapStream<T, U>(\n  source: AsyncIterable<T>,\n  fn: (value: T, index: number) => U | Promise<U>,\n  signal?: AbortSignal,\n): AsyncIterable<U> {\n  let index = 0;\n  for await (const item of withSignal(source, signal)) {\n    yield await fn(item, index++);\n  }\n}\n\n/**\n * Filter values produced by `source`. The predicate may be async.\n *\n * @stable\n */\nexport async function* filter<T>(\n  source: AsyncIterable<T>,\n  pred: (value: T, index: number) => boolean | Promise<boolean>,\n  signal?: AbortSignal,\n): AsyncIterable<T> {\n  let index = 0;\n  for await (const item of withSignal(source, signal)) {\n    if (await pred(item, index++)) yield item;\n  }\n}\n\n/**\n * Take the first `n` items.\n *\n * @stable\n */\nexport async function* take<T>(\n  source: AsyncIterable<T>,\n  n: number,\n  signal?: AbortSignal,\n): AsyncIterable<T> {\n  if (n <= 0) return;\n  let i = 0;\n  for await (const item of withSignal(source, signal)) {\n    yield item;\n    if (++i >= n) return;\n  }\n}\n\n/**\n * Take items as long as `pred` returns truthy. The first item for which\n * `pred` returns falsy ends the stream.\n *\n * @stable\n */\nexport async function* takeWhile<T>(\n  source: AsyncIterable<T>,\n  pred: (value: T, index: number) => boolean | Promise<boolean>,\n  signal?: AbortSignal,\n): AsyncIterable<T> {\n  let index = 0;\n  for await (const item of withSignal(source, signal)) {\n    if (!(await pred(item, index++))) return;\n    yield item;\n  }\n}\n\n/**\n * Merge multiple async iterables into a single output iterable. Items\n * are yielded in the order they arrive (interleaved), not in source\n * order. Cancellation propagates to every upstream iterator.\n *\n * @stable\n */\nexport async function* merge<T>(\n  sources: ReadonlyArray<AsyncIterable<T>>,\n  signal?: AbortSignal,\n): AsyncIterable<T> {\n  if (sources.length === 0) return;\n\n  const iterators = sources.map((s) => s[Symbol.asyncIterator]());\n  type Pending = { iter: AsyncIterator<T>; index: number; promise: Promise<IteratorResult<T>> };\n  const pending: Array<Pending | null> = iterators.map((iter, index) => ({\n    iter,\n    index,\n    promise: iter.next(),\n  }));\n\n  const onAbort = async (): Promise<void> => {\n    await Promise.all(\n      pending.map(async (p) => {\n        if (p && hasReturn(p.iter)) {\n          try {\n            await p.iter.return(undefined);\n          } catch {\n            // Suppress: we are cancelling regardless.\n          }\n        }\n      }),\n    );\n  };\n\n  if (signal?.aborted) {\n    await onAbort();\n    return;\n  }\n\n  const abortListener = (): void => {\n    void onAbort();\n  };\n  signal?.addEventListener('abort', abortListener, { once: true });\n\n  try {\n    while (pending.some((p) => p !== null)) {\n      if (signal?.aborted) return;\n\n      // Race only the still-active iterators.\n      const live = pending.filter((p): p is Pending => p !== null);\n      const winner = await Promise.race(live.map(async (p) => ({ p, result: await p.promise })));\n\n      if (winner.result.done) {\n        pending[winner.p.index] = null;\n        continue;\n      }\n\n      yield winner.result.value;\n\n      // Re-prime the winning iterator.\n      pending[winner.p.index] = {\n        ...winner.p,\n        promise: winner.p.iter.next(),\n      };\n    }\n  } finally {\n    signal?.removeEventListener('abort', abortListener);\n    // Flush any remaining iterators.\n    await Promise.all(\n      pending.map(async (p) => {\n        if (p && hasReturn(p.iter)) {\n          try {\n            await p.iter.return(undefined);\n          } catch {\n            // Suppress.\n          }\n        }\n      }),\n    );\n  }\n}\n\n/**\n * Wrap `source` with abort-signal propagation: when `signal` aborts the\n * underlying iterator's `return()` is called and the loop exits cleanly.\n *\n * @stable\n */\nexport async function* withSignal<T>(\n  source: AsyncIterable<T>,\n  signal?: AbortSignal,\n): AsyncIterable<T> {\n  if (!signal) {\n    yield* source;\n    return;\n  }\n  if (signal.aborted) return;\n\n  const iter = source[Symbol.asyncIterator]();\n  let abortListener: (() => void) | null = null;\n\n  const abortPromise = new Promise<{ aborted: true }>((resolve) => {\n    abortListener = (): void => resolve({ aborted: true });\n    signal.addEventListener('abort', abortListener, { once: true });\n  });\n\n  try {\n    while (true) {\n      const next = iter.next();\n      const winner = await Promise.race([\n        next.then((r) => ({ aborted: false as const, result: r })),\n        abortPromise,\n      ]);\n\n      if (winner.aborted) {\n        if (hasReturn(iter)) {\n          try {\n            await iter.return(undefined);\n          } catch {\n            // Suppress.\n          }\n        }\n        return;\n      }\n      if (winner.result.done) return;\n      yield winner.result.value;\n    }\n  } finally {\n    if (abortListener) signal.removeEventListener('abort', abortListener);\n  }\n}\n"],"mappings":"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"}

package/dist/utils/validation.d.ts

@@ -0,0 +1,67 @@
+//#region src/utils/validation.d.ts
+/**
+ * Type-only Zod compatibility shim. We declare a structural type for the
+ * subset of `zod` we depend on so that `@graphorin/core` can be type-
+ * checked without importing zod directly. Consumers that do `import {
+ *   z } from 'zod'` get the real types via the user's `zod` install (the
+ * peer dependency).
+ *
+ * @stable
+ */
+interface ZodLikeSchema<TOutput = unknown, TInput = unknown> {
+  parse(data: unknown): TOutput;
+  safeParse(data: unknown): ZodLikeSafeParseResult<TOutput, TInput>;
+  /** Internal phantom used by Zod for inference. We don't dereference it. */
+  readonly _output?: TOutput;
+  readonly _input?: TInput;
+}
+/** @stable */
+type ZodLikeSafeParseResult<TOutput, TInput> = {
+  readonly success: true;
+  readonly data: TOutput;
+} | {
+  readonly success: false;
+  readonly error: ZodLikeError<TInput>;
+};
+/** @stable */
+interface ZodLikeError<_TInput = unknown> {
+  readonly name: string;
+  readonly message: string;
+  readonly issues: ReadonlyArray<{
+    readonly path: ReadonlyArray<string | number>;
+    readonly message: string;
+  }>;
+}
+/**
+ * Validate `data` against `schema` and return a `Result` instead of
+ * throwing. Use this in code paths where you want explicit
+ * pattern-matching over success / failure.
+ *
+ * @stable
+ */
+type ValidationResult<T> = {
+  readonly ok: true;
+  readonly value: T;
+} | {
+  readonly ok: false;
+  readonly error: ZodLikeError;
+};
+/**
+ * Synchronous validation wrapper. Does **not** swallow errors thrown by
+ * the schema's transformations — only normalizes the success / failure
+ * signal.
+ *
+ * @stable
+ */
+declare function validate<T>(schema: ZodLikeSchema<T>, data: unknown): ValidationResult<T>;
+/**
+ * Throwing variant of `validate(...)` that surfaces a `TypeError` carrying
+ * a stable, parser-style message. Useful at module-boundary entry points
+ * where a thrown error is the natural failure mode.
+ *
+ * @stable
+ */
+declare function validateOrThrow<T>(schema: ZodLikeSchema<T>, data: unknown, what?: string): T;
+//#endregion
+export { ValidationResult, ZodLikeError, ZodLikeSafeParseResult, ZodLikeSchema, validate, validateOrThrow };
+//# sourceMappingURL=validation.d.ts.map

package/dist/utils/validation.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"validation.d.ts","names":[],"sources":["../../src/utils/validation.ts"],"sourcesContent":[],"mappings":";;AASA;;;;;;;;AASY,UATK,aASiB,CAAA,UAAA,OAAA,EAAA,SAAA,OAAA,CAAA,CAAA;EACW,KAAA,CAAA,IAAA,EAAA,OAAA,CAAA,EATrB,OASqB;EACe,SAAA,CAAA,IAAA,EAAA,OAAA,CAAA,EAThC,sBASgC,CATT,OASS,EATA,MASA,CAAA;EAAb;EAAY,SAAA,OAAA,CAAA,EAPtC,OAOsC;EAG1C,SAAA,MAAY,CAAA,EATT,MASS;AAgB7B;AAWA;AAAkD,KAhCtC,sBAgCsC,CAAA,OAAA,EAAA,MAAA,CAAA,GAAA;EAAd,SAAA,OAAA,EAAA,IAAA;EAAmD,SAAA,IAAA,EA/B1C,OA+B0C;CAAjB,GAAA;EAAgB,SAAA,OAAA,EAAA,KAAA;EAatE,SAAA,KAAA,EA3C+B,YA2ChB,CA3C6B,MA2C7B,CAAA;CAA0B;;AAAmC,UAxC3E,YAwC2E,CAAA,UAAA,OAAA,CAAA,CAAA;EAAC,SAAA,IAAA,EAAA,MAAA;;mBArC1E;mBACA;;;;;;;;;;;KAYP;;kBAC6B;;;kBACC;;;;;;;;;iBAS1B,oBAAoB,cAAc,oBAAoB,iBAAiB;;;;;;;;iBAavE,2BAA2B,cAAc,mCAAmC"}

package/dist/utils/validation.js

@@ -0,0 +1,36 @@
+//#region src/utils/validation.ts
+/**
+* Synchronous validation wrapper. Does **not** swallow errors thrown by
+* the schema's transformations — only normalizes the success / failure
+* signal.
+*
+* @stable
+*/
+function validate(schema, data) {
+	const result = schema.safeParse(data);
+	if (result.success) return {
+		ok: true,
+		value: result.data
+	};
+	return {
+		ok: false,
+		error: result.error
+	};
+}
+/**
+* Throwing variant of `validate(...)` that surfaces a `TypeError` carrying
+* a stable, parser-style message. Useful at module-boundary entry points
+* where a thrown error is the natural failure mode.
+*
+* @stable
+*/
+function validateOrThrow(schema, data, what) {
+	const r = validate(schema, data);
+	if (r.ok) return r.value;
+	const summary = r.error.issues.map((i) => `${i.path.join(".") || "."}: ${i.message}`).join("; ");
+	throw new TypeError(`graphorin: validation failed${what ? ` for ${what}` : ""}: ${summary}`);
+}
+
+//#endregion
+export { validate, validateOrThrow };
+//# sourceMappingURL=validation.js.map

package/dist/utils/validation.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"validation.js","names":[],"sources":["../../src/utils/validation.ts"],"sourcesContent":["/**\n * Type-only Zod compatibility shim. We declare a structural type for the\n * subset of `zod` we depend on so that `@graphorin/core` can be type-\n * checked without importing zod directly. Consumers that do `import {\n *   z } from 'zod'` get the real types via the user's `zod` install (the\n * peer dependency).\n *\n * @stable\n */\nexport interface ZodLikeSchema<TOutput = unknown, TInput = unknown> {\n  parse(data: unknown): TOutput;\n  safeParse(data: unknown): ZodLikeSafeParseResult<TOutput, TInput>;\n  /** Internal phantom used by Zod for inference. We don't dereference it. */\n  readonly _output?: TOutput;\n  readonly _input?: TInput;\n}\n\n/** @stable */\nexport type ZodLikeSafeParseResult<TOutput, TInput> =\n  | { readonly success: true; readonly data: TOutput }\n  | { readonly success: false; readonly error: ZodLikeError<TInput> };\n\n/** @stable */\nexport interface ZodLikeError<_TInput = unknown> {\n  readonly name: string;\n  readonly message: string;\n  readonly issues: ReadonlyArray<{\n    readonly path: ReadonlyArray<string | number>;\n    readonly message: string;\n  }>;\n}\n\n/**\n * Validate `data` against `schema` and return a `Result` instead of\n * throwing. Use this in code paths where you want explicit\n * pattern-matching over success / failure.\n *\n * @stable\n */\nexport type ValidationResult<T> =\n  | { readonly ok: true; readonly value: T }\n  | { readonly ok: false; readonly error: ZodLikeError };\n\n/**\n * Synchronous validation wrapper. Does **not** swallow errors thrown by\n * the schema's transformations — only normalizes the success / failure\n * signal.\n *\n * @stable\n */\nexport function validate<T>(schema: ZodLikeSchema<T>, data: unknown): ValidationResult<T> {\n  const result = schema.safeParse(data);\n  if (result.success) return { ok: true, value: result.data };\n  return { ok: false, error: result.error };\n}\n\n/**\n * Throwing variant of `validate(...)` that surfaces a `TypeError` carrying\n * a stable, parser-style message. Useful at module-boundary entry points\n * where a thrown error is the natural failure mode.\n *\n * @stable\n */\nexport function validateOrThrow<T>(schema: ZodLikeSchema<T>, data: unknown, what?: string): T {\n  const r = validate(schema, data);\n  if (r.ok) return r.value;\n  const summary = r.error.issues.map((i) => `${i.path.join('.') || '.'}: ${i.message}`).join('; ');\n  throw new TypeError(`graphorin: validation failed${what ? ` for ${what}` : ''}: ${summary}`);\n}\n"],"mappings":";;;;;;;;AAkDA,SAAgB,SAAY,QAA0B,MAAoC;CACxF,MAAM,SAAS,OAAO,UAAU,KAAK;AACrC,KAAI,OAAO,QAAS,QAAO;EAAE,IAAI;EAAM,OAAO,OAAO;EAAM;AAC3D,QAAO;EAAE,IAAI;EAAO,OAAO,OAAO;EAAO;;;;;;;;;AAU3C,SAAgB,gBAAmB,QAA0B,MAAe,MAAkB;CAC5F,MAAM,IAAI,SAAS,QAAQ,KAAK;AAChC,KAAI,EAAE,GAAI,QAAO,EAAE;CACnB,MAAM,UAAU,EAAE,MAAM,OAAO,KAAK,MAAM,GAAG,EAAE,KAAK,KAAK,IAAI,IAAI,IAAI,IAAI,EAAE,UAAU,CAAC,KAAK,KAAK;AAChG,OAAM,IAAI,UAAU,+BAA+B,OAAO,QAAQ,SAAS,GAAG,IAAI,UAAU"}

package/package.json

@@ -0,0 +1,82 @@
+{
+  "name": "@graphorin/core",
+  "version": "0.5.0",
+  "description": "Core types, contracts, and utilities for the Graphorin framework. Dependency-free root package every other @graphorin/* package depends on.",
+  "license": "MIT",
+  "author": "Oleksiy Stepurenko",
+  "homepage": "https://github.com/o-stepper/graphorin/tree/main/packages/core",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/o-stepper/graphorin.git",
+    "directory": "packages/core"
+  },
+  "bugs": {
+    "url": "https://github.com/o-stepper/graphorin/issues"
+  },
+  "keywords": [
+    "graphorin",
+    "ai",
+    "agents",
+    "framework",
+    "types",
+    "contracts"
+  ],
+  "type": "module",
+  "engines": {
+    "node": ">=22.0.0"
+  },
+  "main": "./dist/index.js",
+  "module": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js"
+    },
+    "./types": {
+      "types": "./dist/types/index.d.ts",
+      "import": "./dist/types/index.js"
+    },
+    "./contracts": {
+      "types": "./dist/contracts/index.d.ts",
+      "import": "./dist/contracts/index.js"
+    },
+    "./utils": {
+      "types": "./dist/utils/index.d.ts",
+      "import": "./dist/utils/index.js"
+    },
+    "./channels": {
+      "types": "./dist/channels/index.d.ts",
+      "import": "./dist/channels/index.js"
+    },
+    "./package.json": "./package.json"
+  },
+  "files": [
+    "dist",
+    "README.md",
+    "CHANGELOG.md",
+    "LICENSE"
+  ],
+  "peerDependencies": {
+    "zod": "^3.23.0 || ^4.0.0"
+  },
+  "peerDependenciesMeta": {
+    "zod": {
+      "optional": false
+    }
+  },
+  "publishConfig": {
+    "access": "public",
+    "provenance": true
+  },
+  "devDependencies": {
+    "zod": "^3.25.0"
+  },
+  "scripts": {
+    "build": "tsdown",
+    "typecheck": "tsc --noEmit && tsc -p tsconfig.tests.json",
+    "test": "vitest run",
+    "lint": "biome check .",
+    "clean": "rimraf dist .turbo *.tsbuildinfo"
+  }
+}