hazo_collect 0.2.1 → 0.2.2

package/CHANGE_LOG.md

@@ -1,6 +1,56 @@
 # hazo_collect — Change Log
 
-## 0.2.1 — 2026-06-12
+## 0.2.2 — 2026-06-14
+
+### Fixes — CJS-host plugin discovery (empty-registry bug)
+
+A downstream CommonJS app (ocdata) whose worker runs under `tsx` booted with an **empty plugin
+registry** — `discover()` returned `[]`, so the operator UI (`/plugins/<name>`, `/health`,
+`/explore`) showed nothing. Two packaging/runtime defects combined to make folder plugins
+undiscoverable; both are now fixed.
+
+- **Process-global registry singleton** (`src/sdk/index.ts`). The collector and sink registries
+  were module-level `const _collectors = new Map()` / `const _sinks = new Map()`. tsup inlined
+  `src/sdk/index.ts` into **both** the `sdk` and `server` bundles, and a CJS host loaded the ESM
+  build a second time under a different module format — yielding multiple independent Maps.
+  `defineCollector` (via `hazo_collect/sdk`) wrote to one Map while `discover()` →
+  `listCollectors()` (via `hazo_collect/server`) read another, which was never written to. The
+  registries are now keyed on `Symbol.for('hazo_collect.collectors')` /
+  `Symbol.for('hazo_collect.sinks')` and stashed on `globalThis`, so every copy of the module —
+  regardless of bundle or module format — coalesces onto a single store. Public API
+  (`defineCollector`, `defineSink`, `getCollector`, `getSink`, `listCollectors`,
+  `resetCollectorRegistry`) is unchanged.
+- **`exports` map conditions** (`package.json`). `.` and `./server` declared only an `import`
+  condition, so a CommonJS host (which resolves with the `require`/`node` condition set) threw
+  `ERR_PACKAGE_PATH_NOT_EXPORTED` on `require('hazo_collect')` / `require('hazo_collect/server')`.
+  Both subpaths now also declare a `default` condition (mirroring `./sdk`), so CJS hosts resolve
+  them.
+- **tsup `splitting: true`** (`tsup.config.ts`). Code-splitting extracts the shared registry module
+  into a common chunk that both the `sdk` and `server` bundles import, rather than inlining a
+  separate copy into each. The `globalThis` store is the real safety net; this keeps the emitted
+  bundles clean (verified: `dist/sdk/index.js` and `dist/server/index.js` import the same
+  registry chunk).
+- **Regression test** (`src/__tests__/registry_singleton.test.ts`). Loads `src/sdk/index.ts` twice
+  as independent module instances (via `jest.isolateModulesAsync`) — reproducing the duplicated
+  bundle / dual-format condition — and asserts a collector registered through one instance is
+  visible through the other. 71/71 tests green.
+
+## 0.2.1 — 2026-06-14
+
+### Fixes — zod v4 compatibility + manifest input/output typing
+
+- **zod v4 `z.record`** — all four record schemas migrated to the two-arg form
+  (`z.record(keyType, valueType)`) required by zod v4: `ManifestSchema.inputs`/`labels`,
+  `RunEnvelopeSchema.inputs`/`secrets`, `RunResultSchema.metrics`. The single-arg form left the
+  schema modules with a `tsc` error, which silently collapsed `Manifest` to a loose type and masked
+  a cascade of downstream type errors. `type-check` is now green for the first time under zod v4.
+- **`ManifestInput` type** — new `z.input<typeof ManifestSchema>` export. The SDK
+  (`defineCollector` / `defineSink`), `RegistryEntry`, `persistRegistry`, and `validateInputs` now
+  accept this author-input shape, so `.default()` fields (`timezone`, `timeout_sec`, `concurrency`,
+  `retry.*`) may be **omitted** when authoring a collector — the registry runs `parseManifest` to
+  fill defaults before the runtime reads them. No runtime behavior change.
+- **Tests** — jest mock generics tightened in `runtime.test.ts` / `registry.test.ts` so the strict
+  manifest types type-check. 68/68 tests still green.
 
 ### Test-app improvements (no API changes)
 

package/README.md

@@ -10,6 +10,15 @@ npm install hazo_collect
 
 Peer deps: `hazo_core`, `hazo_connect`. Optional: `hazo_secure` (for secrets injection).
 
+### Module formats
+
+`hazo_collect` ships as ESM, but every subpath (`.`, `./server`, `./sdk`) is resolvable from a
+**CommonJS** host as well — including a Next.js project (`"type": "commonjs"`) whose worker runs
+under `tsx`. Both `import('hazo_collect/server')` and `require('hazo_collect/server')` resolve, and a
+plugin that registers via `import { defineCollector } from 'hazo_collect/sdk'` is discovered by a
+`discover()` call made from the CJS worker — the registry is shared process-wide regardless of how
+each side is loaded.
+
 ## Quick start
 
 ### 1. Define a collector (SDK)
@@ -77,13 +86,23 @@ const result = await manager.runNow({ plugin: 'my_source' });
 
 | Export | Description |
 |---|---|
-| `defineCollector(def)` | Register a collector in the module-level registry |
+| `defineCollector(def)` | Register a collector in the process-global registry |
 | `getCollector(name)` | Look up a registered collector by name |
 | `listCollectors()` | Return all registered collectors |
 | `defineSink(def)` | Register a sink (data destination) |
 | `getSink(name)` | Look up a registered sink |
 | `resetCollectorRegistry()` | Clear all registrations (test hygiene) |
 
+The registry is a **process-global singleton** keyed on `globalThis[Symbol.for('hazo_collect.collectors')]`.
+This guarantees that a collector registered through `hazo_collect/sdk` is visible to `discover()` /
+`listCollectors()` in `hazo_collect/server`, even when the two entry points are bundled separately or
+loaded under different module formats (see [Module formats](#module-formats) below).
+
+`defineCollector` / `defineSink` accept the manifest **input** shape (`ManifestInput`): fields with
+defaults — `timezone`, `timeout_sec`, `concurrency`, `retry.*` — may be omitted. The registry runs
+`parseManifest` to fill defaults before the runtime reads them, so wrapping the literal in
+`parseManifest(...)` (as in the quick start above) is optional.
+
 ## Database tables
 
 Run migrations from `hazo_collect/ddl/sqlite.sql` (SQLite) or `hazo_collect/ddl/postgres.sql` (PostgreSQL):

package/dist/chunk-6RFFJN6X.js

@@ -0,0 +1,131 @@
+// src/contract-version.ts
+var CONTRACT_VERSION = "1.0.0";
+
+// src/schema/manifest.ts
+import { z } from "zod";
+import { fromZodValidation } from "hazo_core";
+var RetrySchema = z.object({
+  max: z.number().int().min(0).default(3),
+  backoff: z.enum(["exponential", "linear", "constant"]).default("exponential"),
+  base_ms: z.number().int().min(0).default(1e3),
+  jitter: z.boolean().default(true)
+});
+var ManifestSchema = z.object({
+  name: z.string().min(1),
+  kind: z.enum(["source", "sink"]),
+  version: z.string().min(1),
+  runtime: z.enum(["node", "python"]),
+  entry: z.string().min(1),
+  schedule: z.string().optional(),
+  timezone: z.string().default("UTC"),
+  timeout_sec: z.number().int().min(1).default(600),
+  concurrency: z.number().int().min(1).default(1),
+  retry: RetrySchema.optional(),
+  inputs: z.record(z.string(), z.unknown()).optional(),
+  // JSON-Schema object
+  produces: z.array(z.string()).optional(),
+  consumes: z.array(z.string()).optional(),
+  secrets: z.array(z.string()).optional(),
+  idempotency_key: z.array(z.string()).min(1),
+  labels: z.record(z.string(), z.string()).optional()
+});
+function parseManifest(input) {
+  const result = ManifestSchema.safeParse(input);
+  if (!result.success) {
+    throw fromZodValidation(result.error, {
+      pkg: "hazo_collect",
+      code: "HAZO_COLLECT_INVALID_MANIFEST"
+    });
+  }
+  return result.data;
+}
+
+// src/schema/run-result.ts
+import { z as z2 } from "zod";
+import { fromZodValidation as fromZodValidation2 } from "hazo_core";
+var RunErrorSchema = z2.object({
+  code: z2.string(),
+  message: z2.string(),
+  retryable: z2.boolean().optional(),
+  context: z2.unknown().optional()
+});
+var RunResultSchema = z2.object({
+  plugin: z2.string(),
+  run_id: z2.string(),
+  kind: z2.enum(["source", "sink"]),
+  started_at: z2.string(),
+  completed_at: z2.string(),
+  status: z2.enum(["success", "partial", "failed"]),
+  records_fetched: z2.number().int().min(0),
+  records_written: z2.number().int().min(0),
+  watermark: z2.string().optional(),
+  errors: z2.array(RunErrorSchema).default([]),
+  metrics: z2.record(z2.string(), z2.number()).optional(),
+  contract_version: z2.string().default(CONTRACT_VERSION)
+});
+function parseRunResult(input) {
+  const result = RunResultSchema.safeParse(input);
+  if (!result.success) {
+    throw fromZodValidation2(result.error, {
+      pkg: "hazo_collect",
+      code: "HAZO_COLLECT_INVALID_RUN_RESULT"
+    });
+  }
+  return result.data;
+}
+
+// src/validate/inputs.ts
+import { Ajv } from "ajv";
+import { HazoValidationError } from "hazo_core";
+var ajv = new Ajv({ allErrors: true });
+function validateInputs(manifest, payload) {
+  if (!manifest.inputs) {
+    return;
+  }
+  const schemaIsValid = ajv.validateSchema(manifest.inputs);
+  if (!schemaIsValid) {
+    const issues = (ajv.errors ?? []).map((e) => ({
+      path: [e.instancePath || e.schemaPath],
+      message: e.message ?? "invalid schema"
+    }));
+    throw new HazoValidationError({
+      code: "HAZO_COLLECT_MALFORMED_MANIFEST",
+      pkg: "hazo_collect",
+      message: `manifest "${manifest.name}" has an invalid inputs JSON-Schema`,
+      issues
+    });
+  }
+  let validate;
+  try {
+    validate = ajv.compile(manifest.inputs);
+  } catch (err) {
+    throw new HazoValidationError({
+      code: "HAZO_COLLECT_MALFORMED_MANIFEST",
+      pkg: "hazo_collect",
+      message: `manifest "${manifest.name}" inputs schema could not be compiled: ${String(err)}`,
+      issues: []
+    });
+  }
+  const valid = validate(payload);
+  if (!valid) {
+    const issues = (validate.errors ?? []).map((e) => ({
+      path: [e.instancePath],
+      message: e.message ?? "validation failed"
+    }));
+    throw new HazoValidationError({
+      code: "HAZO_COLLECT_INVALID_INPUTS",
+      pkg: "hazo_collect",
+      message: `inputs for plugin "${manifest.name}" failed validation`,
+      issues
+    });
+  }
+}
+
+export {
+  CONTRACT_VERSION,
+  ManifestSchema,
+  parseManifest,
+  RunResultSchema,
+  parseRunResult,
+  validateInputs
+};

package/dist/chunk-NNLJFKX5.js

@@ -0,0 +1,51 @@
+// src/sdk/index.ts
+import { HazoConfigError } from "hazo_core";
+var COLLECTOR_REGISTRY_KEY = /* @__PURE__ */ Symbol.for("hazo_collect.collectors");
+var SINK_REGISTRY_KEY = /* @__PURE__ */ Symbol.for("hazo_collect.sinks");
+var _g = globalThis;
+var _collectors = _g[COLLECTOR_REGISTRY_KEY] ?? (_g[COLLECTOR_REGISTRY_KEY] = /* @__PURE__ */ new Map());
+var _sinks = _g[SINK_REGISTRY_KEY] ?? (_g[SINK_REGISTRY_KEY] = /* @__PURE__ */ new Map());
+function defineCollector(def) {
+  if (_collectors.has(def.manifest.name)) {
+    throw new HazoConfigError({
+      code: "HAZO_COLLECT_DUPLICATE_COLLECTOR",
+      pkg: "hazo_collect",
+      message: `Collector "${def.manifest.name}" is already registered`
+    });
+  }
+  _collectors.set(def.manifest.name, def);
+  return def;
+}
+function getCollector(name) {
+  return _collectors.get(name);
+}
+function listCollectors() {
+  return Array.from(_collectors.values());
+}
+function defineSink(def) {
+  if (_sinks.has(def.manifest.name)) {
+    throw new HazoConfigError({
+      code: "HAZO_COLLECT_DUPLICATE_SINK",
+      pkg: "hazo_collect",
+      message: `Sink "${def.manifest.name}" is already registered`
+    });
+  }
+  _sinks.set(def.manifest.name, def);
+  return def;
+}
+function getSink(name) {
+  return _sinks.get(name);
+}
+function resetCollectorRegistry() {
+  _collectors.clear();
+  _sinks.clear();
+}
+
+export {
+  defineCollector,
+  getCollector,
+  listCollectors,
+  defineSink,
+  getSink,
+  resetCollectorRegistry
+};

package/dist/{index-C47n5Xur.d.ts → index-Dls93tTu.d.ts}

@@ -1,5 +1,5 @@
 import { HazoCoreLogger } from 'hazo_core';
-import { M as Manifest, R as RunEnvelope } from './run-envelope-COvdsleR.js';
+import { a as ManifestInput, R as RunEnvelope } from './run-envelope-BX10F3lB.js';
 import { DbResult, HazoConnectAdapter } from 'hazo_connect/server';
 
 interface LandingRow {
@@ -44,11 +44,11 @@ type CollectorOutcome = {
     metrics?: Record<string, number>;
 };
 type CollectorDefinition = {
-    manifest: Manifest;
+    manifest: ManifestInput;
     run(ctx: CollectorContext): Promise<CollectorOutcome>;
 };
 type SinkDefinition = {
-    manifest: Manifest;
+    manifest: ManifestInput;
 };
 declare function defineCollector(def: CollectorDefinition): CollectorDefinition;
 declare function getCollector(name: string): CollectorDefinition | undefined;

package/dist/index.d.ts

@@ -1,10 +1,10 @@
-import { M as Manifest } from './run-envelope-COvdsleR.js';
-export { a as ManifestSchema, R as RunEnvelope, b as RunEnvelopeSchema, p as parseManifest, c as parseRunEnvelope } from './run-envelope-COvdsleR.js';
-export { R as RunError, a as RunResult, b as RunResultSchema, p as parseRunResult } from './run-result-qW7bJEZ-.js';
+import { a as ManifestInput } from './run-envelope-BX10F3lB.js';
+export { M as Manifest, b as ManifestSchema, R as RunEnvelope, c as RunEnvelopeSchema, p as parseManifest, d as parseRunEnvelope } from './run-envelope-BX10F3lB.js';
+export { R as RunError, a as RunResult, b as RunResultSchema, p as parseRunResult } from './run-result-yw8Iqipg.js';
 import 'zod';
 
 declare const CONTRACT_VERSION = "1.0.0";
 
-declare function validateInputs(manifest: Manifest, payload: unknown): void;
+declare function validateInputs(manifest: ManifestInput, payload: unknown): void;
 
-export { CONTRACT_VERSION, Manifest, validateInputs };
+export { CONTRACT_VERSION, ManifestInput, validateInputs };

package/dist/index.js

@@ -1,152 +1,38 @@
-// src/contract-version.ts
-var CONTRACT_VERSION = "1.0.0";
+import {
+  CONTRACT_VERSION,
+  ManifestSchema,
+  RunResultSchema,
+  parseManifest,
+  parseRunResult,
+  validateInputs
+} from "./chunk-6RFFJN6X.js";
 
-// src/schema/manifest.ts
+// src/schema/run-envelope.ts
 import { z } from "zod";
 import { fromZodValidation } from "hazo_core";
-var RetrySchema = z.object({
-  max: z.number().int().min(0).default(3),
-  backoff: z.enum(["exponential", "linear", "constant"]).default("exponential"),
-  base_ms: z.number().int().min(0).default(1e3),
-  jitter: z.boolean().default(true)
-});
-var ManifestSchema = z.object({
-  name: z.string().min(1),
-  kind: z.enum(["source", "sink"]),
-  version: z.string().min(1),
-  runtime: z.enum(["node", "python"]),
-  entry: z.string().min(1),
-  schedule: z.string().optional(),
-  timezone: z.string().default("UTC"),
-  timeout_sec: z.number().int().min(1).default(600),
-  concurrency: z.number().int().min(1).default(1),
-  retry: RetrySchema.optional(),
-  inputs: z.record(z.unknown()).optional(),
-  // JSON-Schema object
-  produces: z.array(z.string()).optional(),
-  consumes: z.array(z.string()).optional(),
-  secrets: z.array(z.string()).optional(),
-  idempotency_key: z.array(z.string()).min(1),
-  labels: z.record(z.string()).optional()
-});
-function parseManifest(input) {
-  const result = ManifestSchema.safeParse(input);
-  if (!result.success) {
-    throw fromZodValidation(result.error, {
-      pkg: "hazo_collect",
-      code: "HAZO_COLLECT_INVALID_MANIFEST"
-    });
-  }
-  return result.data;
-}
-
-// src/schema/run-result.ts
-import { z as z2 } from "zod";
-import { fromZodValidation as fromZodValidation2 } from "hazo_core";
-var RunErrorSchema = z2.object({
-  code: z2.string(),
-  message: z2.string(),
-  retryable: z2.boolean().optional(),
-  context: z2.unknown().optional()
-});
-var RunResultSchema = z2.object({
-  plugin: z2.string(),
-  run_id: z2.string(),
-  kind: z2.enum(["source", "sink"]),
-  started_at: z2.string(),
-  completed_at: z2.string(),
-  status: z2.enum(["success", "partial", "failed"]),
-  records_fetched: z2.number().int().min(0),
-  records_written: z2.number().int().min(0),
-  watermark: z2.string().optional(),
-  errors: z2.array(RunErrorSchema).default([]),
-  metrics: z2.record(z2.number()).optional(),
-  contract_version: z2.string().default(CONTRACT_VERSION)
-});
-function parseRunResult(input) {
-  const result = RunResultSchema.safeParse(input);
-  if (!result.success) {
-    throw fromZodValidation2(result.error, {
-      pkg: "hazo_collect",
-      code: "HAZO_COLLECT_INVALID_RUN_RESULT"
-    });
-  }
-  return result.data;
-}
-
-// src/schema/run-envelope.ts
-import { z as z3 } from "zod";
-import { fromZodValidation as fromZodValidation3 } from "hazo_core";
-var RunEnvelopeSchema = z3.object({
-  run_id: z3.string(),
-  correlation_id: z3.string(),
-  plugin: z3.string(),
-  inputs: z3.record(z3.unknown()).default({}),
-  secrets: z3.record(z3.string()).default({}),
-  window: z3.object({
-    since: z3.string().optional(),
-    until: z3.string().optional()
+var RunEnvelopeSchema = z.object({
+  run_id: z.string(),
+  correlation_id: z.string(),
+  plugin: z.string(),
+  inputs: z.record(z.string(), z.unknown()).default({}),
+  secrets: z.record(z.string(), z.string()).default({}),
+  window: z.object({
+    since: z.string().optional(),
+    until: z.string().optional()
   }).optional(),
-  attempt: z3.number().int().min(1).default(1),
-  contract_version: z3.string().default(CONTRACT_VERSION)
+  attempt: z.number().int().min(1).default(1),
+  contract_version: z.string().default(CONTRACT_VERSION)
 });
 function parseRunEnvelope(input) {
   const result = RunEnvelopeSchema.safeParse(input);
   if (!result.success) {
-    throw fromZodValidation3(result.error, {
+    throw fromZodValidation(result.error, {
       pkg: "hazo_collect",
       code: "HAZO_COLLECT_INVALID_RUN_ENVELOPE"
     });
   }
   return result.data;
 }
-
-// src/validate/inputs.ts
-import { Ajv } from "ajv";
-import { HazoValidationError } from "hazo_core";
-var ajv = new Ajv({ allErrors: true });
-function validateInputs(manifest, payload) {
-  if (!manifest.inputs) {
-    return;
-  }
-  const schemaIsValid = ajv.validateSchema(manifest.inputs);
-  if (!schemaIsValid) {
-    const issues = (ajv.errors ?? []).map((e) => ({
-      path: [e.instancePath || e.schemaPath],
-      message: e.message ?? "invalid schema"
-    }));
-    throw new HazoValidationError({
-      code: "HAZO_COLLECT_MALFORMED_MANIFEST",
-      pkg: "hazo_collect",
-      message: `manifest "${manifest.name}" has an invalid inputs JSON-Schema`,
-      issues
-    });
-  }
-  let validate;
-  try {
-    validate = ajv.compile(manifest.inputs);
-  } catch (err) {
-    throw new HazoValidationError({
-      code: "HAZO_COLLECT_MALFORMED_MANIFEST",
-      pkg: "hazo_collect",
-      message: `manifest "${manifest.name}" inputs schema could not be compiled: ${String(err)}`,
-      issues: []
-    });
-  }
-  const valid = validate(payload);
-  if (!valid) {
-    const issues = (validate.errors ?? []).map((e) => ({
-      path: [e.instancePath],
-      message: e.message ?? "validation failed"
-    }));
-    throw new HazoValidationError({
-      code: "HAZO_COLLECT_INVALID_INPUTS",
-      pkg: "hazo_collect",
-      message: `inputs for plugin "${manifest.name}" failed validation`,
-      issues
-    });
-  }
-}
 export {
   CONTRACT_VERSION,
   ManifestSchema,

package/dist/run-envelope-BX10F3lB.d.ts

@@ -0,0 +1,56 @@
+import { z } from 'zod';
+
+declare const ManifestSchema: z.ZodObject<{
+    name: z.ZodString;
+    kind: z.ZodEnum<{
+        source: "source";
+        sink: "sink";
+    }>;
+    version: z.ZodString;
+    runtime: z.ZodEnum<{
+        node: "node";
+        python: "python";
+    }>;
+    entry: z.ZodString;
+    schedule: z.ZodOptional<z.ZodString>;
+    timezone: z.ZodDefault<z.ZodString>;
+    timeout_sec: z.ZodDefault<z.ZodNumber>;
+    concurrency: z.ZodDefault<z.ZodNumber>;
+    retry: z.ZodOptional<z.ZodObject<{
+        max: z.ZodDefault<z.ZodNumber>;
+        backoff: z.ZodDefault<z.ZodEnum<{
+            exponential: "exponential";
+            linear: "linear";
+            constant: "constant";
+        }>>;
+        base_ms: z.ZodDefault<z.ZodNumber>;
+        jitter: z.ZodDefault<z.ZodBoolean>;
+    }, z.core.$strip>>;
+    inputs: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    produces: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    consumes: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    secrets: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    idempotency_key: z.ZodArray<z.ZodString>;
+    labels: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+}, z.core.$strip>;
+type Manifest = z.infer<typeof ManifestSchema>;
+type ManifestInput = z.input<typeof ManifestSchema>;
+declare function parseManifest(input: unknown): Manifest;
+
+declare const RunEnvelopeSchema: z.ZodObject<{
+    run_id: z.ZodString;
+    correlation_id: z.ZodString;
+    plugin: z.ZodString;
+    inputs: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    secrets: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodString>>;
+    window: z.ZodOptional<z.ZodObject<{
+        since: z.ZodOptional<z.ZodString>;
+        until: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>;
+    attempt: z.ZodDefault<z.ZodNumber>;
+    contract_version: z.ZodDefault<z.ZodString>;
+}, z.core.$strip>;
+type RunEnvelope = z.infer<typeof RunEnvelopeSchema>;
+declare function parseRunEnvelope(input: unknown): RunEnvelope;
+
+export { type Manifest as M, type RunEnvelope as R, type ManifestInput as a, ManifestSchema as b, RunEnvelopeSchema as c, parseRunEnvelope as d, parseManifest as p };

package/dist/run-result-yw8Iqipg.d.ts

@@ -0,0 +1,39 @@
+import { z } from 'zod';
+
+declare const RunErrorSchema: z.ZodObject<{
+    code: z.ZodString;
+    message: z.ZodString;
+    retryable: z.ZodOptional<z.ZodBoolean>;
+    context: z.ZodOptional<z.ZodUnknown>;
+}, z.core.$strip>;
+declare const RunResultSchema: z.ZodObject<{
+    plugin: z.ZodString;
+    run_id: z.ZodString;
+    kind: z.ZodEnum<{
+        source: "source";
+        sink: "sink";
+    }>;
+    started_at: z.ZodString;
+    completed_at: z.ZodString;
+    status: z.ZodEnum<{
+        success: "success";
+        partial: "partial";
+        failed: "failed";
+    }>;
+    records_fetched: z.ZodNumber;
+    records_written: z.ZodNumber;
+    watermark: z.ZodOptional<z.ZodString>;
+    errors: z.ZodDefault<z.ZodArray<z.ZodObject<{
+        code: z.ZodString;
+        message: z.ZodString;
+        retryable: z.ZodOptional<z.ZodBoolean>;
+        context: z.ZodOptional<z.ZodUnknown>;
+    }, z.core.$strip>>>;
+    metrics: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodNumber>>;
+    contract_version: z.ZodDefault<z.ZodString>;
+}, z.core.$strip>;
+type RunResult = z.infer<typeof RunResultSchema>;
+type RunError = z.infer<typeof RunErrorSchema>;
+declare function parseRunResult(input: unknown): RunResult;
+
+export { type RunError as R, type RunResult as a, RunResultSchema as b, parseRunResult as p };

package/dist/sdk/index.d.ts

@@ -1,5 +1,5 @@
 import 'hazo_core';
-import '../run-envelope-COvdsleR.js';
-export { a as CollectorContext, b as CollectorDefinition, c as CollectorOutcome, S as SinkDefinition, g as defineCollector, h as defineSink, i as getCollector, j as getSink, l as listCollectors, r as resetCollectorRegistry } from '../index-C47n5Xur.js';
+import '../run-envelope-BX10F3lB.js';
+export { a as CollectorContext, b as CollectorDefinition, c as CollectorOutcome, S as SinkDefinition, g as defineCollector, h as defineSink, i as getCollector, j as getSink, l as listCollectors, r as resetCollectorRegistry } from '../index-Dls93tTu.js';
 import 'zod';
 import 'hazo_connect/server';

package/dist/sdk/index.js

@@ -1,42 +1,11 @@
-// src/sdk/index.ts
-import { HazoConfigError } from "hazo_core";
-var _collectors = /* @__PURE__ */ new Map();
-var _sinks = /* @__PURE__ */ new Map();
-function defineCollector(def) {
-  if (_collectors.has(def.manifest.name)) {
-    throw new HazoConfigError({
-      code: "HAZO_COLLECT_DUPLICATE_COLLECTOR",
-      pkg: "hazo_collect",
-      message: `Collector "${def.manifest.name}" is already registered`
-    });
-  }
-  _collectors.set(def.manifest.name, def);
-  return def;
-}
-function getCollector(name) {
-  return _collectors.get(name);
-}
-function listCollectors() {
-  return Array.from(_collectors.values());
-}
-function defineSink(def) {
-  if (_sinks.has(def.manifest.name)) {
-    throw new HazoConfigError({
-      code: "HAZO_COLLECT_DUPLICATE_SINK",
-      pkg: "hazo_collect",
-      message: `Sink "${def.manifest.name}" is already registered`
-    });
-  }
-  _sinks.set(def.manifest.name, def);
-  return def;
-}
-function getSink(name) {
-  return _sinks.get(name);
-}
-function resetCollectorRegistry() {
-  _collectors.clear();
-  _sinks.clear();
-}
+import {
+  defineCollector,
+  defineSink,
+  getCollector,
+  getSink,
+  listCollectors,
+  resetCollectorRegistry
+} from "../chunk-NNLJFKX5.js";
 export {
   defineCollector,
   defineSink,

package/dist/server/index.d.ts

@@ -1,8 +1,8 @@
-import { b as CollectorDefinition, c as CollectorOutcome } from '../index-C47n5Xur.js';
-export { C as CanonicalTarget, L as LandingRow, W as WriteAdapter, d as WriteArgs, e as WriteResult, f as createWriteAdapter } from '../index-C47n5Xur.js';
+import { b as CollectorDefinition, c as CollectorOutcome } from '../index-Dls93tTu.js';
+export { C as CanonicalTarget, L as LandingRow, W as WriteAdapter, d as WriteArgs, e as WriteResult, f as createWriteAdapter } from '../index-Dls93tTu.js';
 import { HazoConnectAdapter, DbResult } from 'hazo_connect/server';
-import { a as RunResult } from '../run-result-qW7bJEZ-.js';
-import { M as Manifest, R as RunEnvelope } from '../run-envelope-COvdsleR.js';
+import { a as RunResult } from '../run-result-yw8Iqipg.js';
+import { a as ManifestInput, R as RunEnvelope } from '../run-envelope-BX10F3lB.js';
 import 'hazo_core';
 import 'zod';
 
@@ -14,7 +14,7 @@ interface DiscoverOptions {
 declare function discover(opts: DiscoverOptions): Promise<Registry>;
 
 interface RegistryEntry {
-    manifest: Manifest;
+    manifest: ManifestInput;
     worker: CollectorDefinition;
 }
 interface Registry {
@@ -28,7 +28,7 @@ declare function createInMemoryRegistry(): Registry;
  * Invalid manifests (parse failure) are quarantined: valid=0, quarantine_reason=error message.
  */
 declare function persistRegistry(adapter: HazoConnectAdapter, entries: Array<{
-    manifest: Manifest;
+    manifest: ManifestInput;
     source?: string;
 }>, opts?: {
     reseed?: boolean;

package/dist/server/index.js

@@ -1,3 +1,14 @@
+import {
+  CONTRACT_VERSION,
+  RunResultSchema,
+  parseManifest,
+  validateInputs
+} from "../chunk-6RFFJN6X.js";
+import {
+  getCollector,
+  listCollectors
+} from "../chunk-NNLJFKX5.js";
+
 // src/server/write-adapter.ts
 import { QueryBuilder, wrapResult } from "hazo_connect/server";
 import { generateRequestId } from "hazo_core";
@@ -43,80 +54,6 @@ function createWriteAdapter(adapter) {
 import { QueryBuilder as QueryBuilder2, wrapResult as wrapResult2 } from "hazo_connect/server";
 import { generateRequestId as generateRequestId2, getCorrelationId, withContext } from "hazo_core";
 
-// src/validate/inputs.ts
-import { Ajv } from "ajv";
-import { HazoValidationError } from "hazo_core";
-var ajv = new Ajv({ allErrors: true });
-function validateInputs(manifest, payload) {
-  if (!manifest.inputs) {
-    return;
-  }
-  const schemaIsValid = ajv.validateSchema(manifest.inputs);
-  if (!schemaIsValid) {
-    const issues = (ajv.errors ?? []).map((e) => ({
-      path: [e.instancePath || e.schemaPath],
-      message: e.message ?? "invalid schema"
-    }));
-    throw new HazoValidationError({
-      code: "HAZO_COLLECT_MALFORMED_MANIFEST",
-      pkg: "hazo_collect",
-      message: `manifest "${manifest.name}" has an invalid inputs JSON-Schema`,
-      issues
-    });
-  }
-  let validate;
-  try {
-    validate = ajv.compile(manifest.inputs);
-  } catch (err) {
-    throw new HazoValidationError({
-      code: "HAZO_COLLECT_MALFORMED_MANIFEST",
-      pkg: "hazo_collect",
-      message: `manifest "${manifest.name}" inputs schema could not be compiled: ${String(err)}`,
-      issues: []
-    });
-  }
-  const valid = validate(payload);
-  if (!valid) {
-    const issues = (validate.errors ?? []).map((e) => ({
-      path: [e.instancePath],
-      message: e.message ?? "validation failed"
-    }));
-    throw new HazoValidationError({
-      code: "HAZO_COLLECT_INVALID_INPUTS",
-      pkg: "hazo_collect",
-      message: `inputs for plugin "${manifest.name}" failed validation`,
-      issues
-    });
-  }
-}
-
-// src/contract-version.ts
-var CONTRACT_VERSION = "1.0.0";
-
-// src/schema/run-result.ts
-import { z } from "zod";
-import { fromZodValidation } from "hazo_core";
-var RunErrorSchema = z.object({
-  code: z.string(),
-  message: z.string(),
-  retryable: z.boolean().optional(),
-  context: z.unknown().optional()
-});
-var RunResultSchema = z.object({
-  plugin: z.string(),
-  run_id: z.string(),
-  kind: z.enum(["source", "sink"]),
-  started_at: z.string(),
-  completed_at: z.string(),
-  status: z.enum(["success", "partial", "failed"]),
-  records_fetched: z.number().int().min(0),
-  records_written: z.number().int().min(0),
-  watermark: z.string().optional(),
-  errors: z.array(RunErrorSchema).default([]),
-  metrics: z.record(z.number()).optional(),
-  contract_version: z.string().default(CONTRACT_VERSION)
-});
-
 // src/runtime/node.ts
 import { createLogger } from "hazo_core";
 
@@ -432,55 +369,6 @@ function createManager(opts) {
 // src/registry/index.ts
 import { QueryBuilder as QueryBuilder4, wrapResult as wrapResult3 } from "hazo_connect/server";
 
-// src/schema/manifest.ts
-import { z as z2 } from "zod";
-import { fromZodValidation as fromZodValidation2 } from "hazo_core";
-var RetrySchema = z2.object({
-  max: z2.number().int().min(0).default(3),
-  backoff: z2.enum(["exponential", "linear", "constant"]).default("exponential"),
-  base_ms: z2.number().int().min(0).default(1e3),
-  jitter: z2.boolean().default(true)
-});
-var ManifestSchema = z2.object({
-  name: z2.string().min(1),
-  kind: z2.enum(["source", "sink"]),
-  version: z2.string().min(1),
-  runtime: z2.enum(["node", "python"]),
-  entry: z2.string().min(1),
-  schedule: z2.string().optional(),
-  timezone: z2.string().default("UTC"),
-  timeout_sec: z2.number().int().min(1).default(600),
-  concurrency: z2.number().int().min(1).default(1),
-  retry: RetrySchema.optional(),
-  inputs: z2.record(z2.unknown()).optional(),
-  // JSON-Schema object
-  produces: z2.array(z2.string()).optional(),
-  consumes: z2.array(z2.string()).optional(),
-  secrets: z2.array(z2.string()).optional(),
-  idempotency_key: z2.array(z2.string()).min(1),
-  labels: z2.record(z2.string()).optional()
-});
-function parseManifest(input) {
-  const result = ManifestSchema.safeParse(input);
-  if (!result.success) {
-    throw fromZodValidation2(result.error, {
-      pkg: "hazo_collect",
-      code: "HAZO_COLLECT_INVALID_MANIFEST"
-    });
-  }
-  return result.data;
-}
-
-// src/sdk/index.ts
-import { HazoConfigError } from "hazo_core";
-var _collectors = /* @__PURE__ */ new Map();
-function getCollector(name) {
-  return _collectors.get(name);
-}
-function listCollectors() {
-  return Array.from(_collectors.values());
-}
-
 // src/registry/discovery.ts
 import { readFileSync, readdirSync } from "fs";
 import { resolve } from "path";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "hazo_collect",
-  "version": "0.2.1",
+  "version": "0.2.2",
   "description": "Collector-manager engine for the Ocdata platform",
   "type": "module",
   "module": "./dist/index.js",
@@ -8,11 +8,13 @@
   "exports": {
     ".": {
       "types": "./dist/index.d.ts",
-      "import": "./dist/index.js"
+      "import": "./dist/index.js",
+      "default": "./dist/index.js"
     },
     "./server": {
       "types": "./dist/server/index.d.ts",
-      "import": "./dist/server/index.js"
+      "import": "./dist/server/index.js",
+      "default": "./dist/server/index.js"
     },
     "./sdk": {
       "types": "./dist/sdk/index.d.ts",
@@ -37,16 +39,16 @@
     "build:test-app": "npm run build && cd test-app && npm run build"
   },
   "dependencies": {
-    "zod": "^3.23.8",
+    "zod": "^4.1.12",
     "ajv": "^8.17.1"
   },
   "peerDependencies": {
-    "hazo_core": "^1.1.0",
-    "hazo_connect": "^3.5.1",
+    "hazo_core": "^1.2.0",
+    "hazo_connect": "^3.7.0",
     "hazo_secure": "^1.3.0",
     "react": "^18.0.0 || ^19.0.0",
     "react-dom": "^18.0.0 || ^19.0.0",
-    "hazo_ui": "^3.4.1"
+    "hazo_ui": "^4.0.0"
   },
   "peerDependenciesMeta": {
     "hazo_secure": {
@@ -72,8 +74,8 @@
     "@types/node": "^22.10.0",
     "@types/react": "^19.0.0",
     "@types/react-dom": "^19.0.0",
-    "hazo_core": "^1.1.0",
-    "hazo_connect": "^3.5.1",
+    "hazo_core": "^1.2.0",
+    "hazo_connect": "^3.7.0",
     "hazo_secure": "^1.3.0"
   },
   "keywords": [],

package/dist/run-envelope-COvdsleR.d.ts

@@ -1,129 +0,0 @@
-import { z } from 'zod';
-
-declare const ManifestSchema: z.ZodObject<{
-    name: z.ZodString;
-    kind: z.ZodEnum<["source", "sink"]>;
-    version: z.ZodString;
-    runtime: z.ZodEnum<["node", "python"]>;
-    entry: z.ZodString;
-    schedule: z.ZodOptional<z.ZodString>;
-    timezone: z.ZodDefault<z.ZodString>;
-    timeout_sec: z.ZodDefault<z.ZodNumber>;
-    concurrency: z.ZodDefault<z.ZodNumber>;
-    retry: z.ZodOptional<z.ZodObject<{
-        max: z.ZodDefault<z.ZodNumber>;
-        backoff: z.ZodDefault<z.ZodEnum<["exponential", "linear", "constant"]>>;
-        base_ms: z.ZodDefault<z.ZodNumber>;
-        jitter: z.ZodDefault<z.ZodBoolean>;
-    }, "strip", z.ZodTypeAny, {
-        max: number;
-        backoff: "exponential" | "linear" | "constant";
-        base_ms: number;
-        jitter: boolean;
-    }, {
-        max?: number | undefined;
-        backoff?: "exponential" | "linear" | "constant" | undefined;
-        base_ms?: number | undefined;
-        jitter?: boolean | undefined;
-    }>>;
-    inputs: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
-    produces: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
-    consumes: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
-    secrets: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
-    idempotency_key: z.ZodArray<z.ZodString, "many">;
-    labels: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
-}, "strip", z.ZodTypeAny, {
-    name: string;
-    kind: "source" | "sink";
-    version: string;
-    runtime: "node" | "python";
-    entry: string;
-    timezone: string;
-    timeout_sec: number;
-    concurrency: number;
-    idempotency_key: string[];
-    schedule?: string | undefined;
-    retry?: {
-        max: number;
-        backoff: "exponential" | "linear" | "constant";
-        base_ms: number;
-        jitter: boolean;
-    } | undefined;
-    inputs?: Record<string, unknown> | undefined;
-    produces?: string[] | undefined;
-    consumes?: string[] | undefined;
-    secrets?: string[] | undefined;
-    labels?: Record<string, string> | undefined;
-}, {
-    name: string;
-    kind: "source" | "sink";
-    version: string;
-    runtime: "node" | "python";
-    entry: string;
-    idempotency_key: string[];
-    schedule?: string | undefined;
-    timezone?: string | undefined;
-    timeout_sec?: number | undefined;
-    concurrency?: number | undefined;
-    retry?: {
-        max?: number | undefined;
-        backoff?: "exponential" | "linear" | "constant" | undefined;
-        base_ms?: number | undefined;
-        jitter?: boolean | undefined;
-    } | undefined;
-    inputs?: Record<string, unknown> | undefined;
-    produces?: string[] | undefined;
-    consumes?: string[] | undefined;
-    secrets?: string[] | undefined;
-    labels?: Record<string, string> | undefined;
-}>;
-type Manifest = z.infer<typeof ManifestSchema>;
-declare function parseManifest(input: unknown): Manifest;
-
-declare const RunEnvelopeSchema: z.ZodObject<{
-    run_id: z.ZodString;
-    correlation_id: z.ZodString;
-    plugin: z.ZodString;
-    inputs: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
-    secrets: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodString>>;
-    window: z.ZodOptional<z.ZodObject<{
-        since: z.ZodOptional<z.ZodString>;
-        until: z.ZodOptional<z.ZodString>;
-    }, "strip", z.ZodTypeAny, {
-        since?: string | undefined;
-        until?: string | undefined;
-    }, {
-        since?: string | undefined;
-        until?: string | undefined;
-    }>>;
-    attempt: z.ZodDefault<z.ZodNumber>;
-    contract_version: z.ZodDefault<z.ZodString>;
-}, "strip", z.ZodTypeAny, {
-    inputs: Record<string, unknown>;
-    secrets: Record<string, string>;
-    plugin: string;
-    run_id: string;
-    contract_version: string;
-    correlation_id: string;
-    attempt: number;
-    window?: {
-        since?: string | undefined;
-        until?: string | undefined;
-    } | undefined;
-}, {
-    plugin: string;
-    run_id: string;
-    correlation_id: string;
-    inputs?: Record<string, unknown> | undefined;
-    secrets?: Record<string, string> | undefined;
-    contract_version?: string | undefined;
-    window?: {
-        since?: string | undefined;
-        until?: string | undefined;
-    } | undefined;
-    attempt?: number | undefined;
-}>;
-type RunEnvelope = z.infer<typeof RunEnvelopeSchema>;
-declare function parseRunEnvelope(input: unknown): RunEnvelope;
-
-export { type Manifest as M, type RunEnvelope as R, ManifestSchema as a, RunEnvelopeSchema as b, parseRunEnvelope as c, parseManifest as p };

package/dist/run-result-qW7bJEZ-.d.ts

@@ -1,88 +0,0 @@
-import { z } from 'zod';
-
-declare const RunErrorSchema: z.ZodObject<{
-    code: z.ZodString;
-    message: z.ZodString;
-    retryable: z.ZodOptional<z.ZodBoolean>;
-    context: z.ZodOptional<z.ZodUnknown>;
-}, "strip", z.ZodTypeAny, {
-    code: string;
-    message: string;
-    retryable?: boolean | undefined;
-    context?: unknown;
-}, {
-    code: string;
-    message: string;
-    retryable?: boolean | undefined;
-    context?: unknown;
-}>;
-declare const RunResultSchema: z.ZodObject<{
-    plugin: z.ZodString;
-    run_id: z.ZodString;
-    kind: z.ZodEnum<["source", "sink"]>;
-    started_at: z.ZodString;
-    completed_at: z.ZodString;
-    status: z.ZodEnum<["success", "partial", "failed"]>;
-    records_fetched: z.ZodNumber;
-    records_written: z.ZodNumber;
-    watermark: z.ZodOptional<z.ZodString>;
-    errors: z.ZodDefault<z.ZodArray<z.ZodObject<{
-        code: z.ZodString;
-        message: z.ZodString;
-        retryable: z.ZodOptional<z.ZodBoolean>;
-        context: z.ZodOptional<z.ZodUnknown>;
-    }, "strip", z.ZodTypeAny, {
-        code: string;
-        message: string;
-        retryable?: boolean | undefined;
-        context?: unknown;
-    }, {
-        code: string;
-        message: string;
-        retryable?: boolean | undefined;
-        context?: unknown;
-    }>, "many">>;
-    metrics: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodNumber>>;
-    contract_version: z.ZodDefault<z.ZodString>;
-}, "strip", z.ZodTypeAny, {
-    status: "success" | "partial" | "failed";
-    kind: "source" | "sink";
-    plugin: string;
-    run_id: string;
-    started_at: string;
-    completed_at: string;
-    records_fetched: number;
-    records_written: number;
-    errors: {
-        code: string;
-        message: string;
-        retryable?: boolean | undefined;
-        context?: unknown;
-    }[];
-    contract_version: string;
-    watermark?: string | undefined;
-    metrics?: Record<string, number> | undefined;
-}, {
-    status: "success" | "partial" | "failed";
-    kind: "source" | "sink";
-    plugin: string;
-    run_id: string;
-    started_at: string;
-    completed_at: string;
-    records_fetched: number;
-    records_written: number;
-    watermark?: string | undefined;
-    errors?: {
-        code: string;
-        message: string;
-        retryable?: boolean | undefined;
-        context?: unknown;
-    }[] | undefined;
-    metrics?: Record<string, number> | undefined;
-    contract_version?: string | undefined;
-}>;
-type RunResult = z.infer<typeof RunResultSchema>;
-type RunError = z.infer<typeof RunErrorSchema>;
-declare function parseRunResult(input: unknown): RunResult;
-
-export { type RunError as R, type RunResult as a, RunResultSchema as b, parseRunResult as p };