@useairfoil/connector-kit 0.6.0 → 0.7.0

package/src/runtime-config/table-bindings.ts

@@ -1,67 +1,30 @@
-import * as Wings from "@useairfoil/wings";
-import { Config, Effect, Schema } from "effect";
+import type { TableIdentifier } from "iceberg-js";
 
-import type { ConnectorDefinition, ResourceName } from "../core/types";
+import { Config, Effect, Schema } from "effect";
 
 import { PlatformRuntimeKey } from "./constants";
 import { RuntimeConfigError } from "./error";
 
-/** Table binding shape accepted in `AIRFOIL_TABLE_BINDINGS`. */
-export type HostedTableBinding =
-  | string
-  | {
-      readonly name: string;
-      readonly partition?: Wings.PartitionValue.Json;
-    };
-
-/** Validated table binding ready for the Wings publisher. */
-export type ResolvedTableBinding = {
-  readonly name: string;
-  readonly partitionValue?: Wings.PartitionValue.PartitionValue;
+type BindingSource = {
+  readonly resources: ReadonlyArray<{ readonly name: string }>;
 };
 
-/** One resolved binding for each resource in a connector manifest. */
-export type ResolvedTableBindings<Connector extends ConnectorDefinition> = Readonly<
-  Record<ResourceName<Connector["resources"]>, ResolvedTableBinding>
+/** An Iceberg table and its storage location for each connector resource. */
+export type TableBinding = TableIdentifier & { readonly location?: string | undefined };
+
+export type ResolvedTableBindings<Source extends BindingSource> = Readonly<
+  Partial<Record<Source["resources"][number]["name"], TableBinding>>
 >;
 
-const RawBindingsSchema = Schema.fromJsonString(Schema.Record(Schema.String, Schema.Unknown));
+const TableIdentifierSchema = Schema.Struct({
+  namespace: Schema.NonEmptyArray(Schema.NonEmptyString),
+  name: Schema.NonEmptyString,
+  location: Schema.optional(Schema.NonEmptyString),
+});
 
-// JSON.parse keeps the last duplicate key, so check before decoding.
-const duplicateTopLevelKey = (json: string): string | undefined => {
-  const keys = new Set<string>();
-  let depth = 0;
-  let expectKey = false;
-  for (let index = 0; index < json.length; index += 1) {
-    const char = json[index];
-    if (char === '"') {
-      const start = index;
-      for (index += 1; index < json.length; index += 1) {
-        if (json[index] === "\\") {
-          index += 1;
-        } else if (json[index] === '"') {
-          break;
-        }
-      }
-      if (depth === 1 && expectKey) {
-        const key = JSON.parse(json.slice(start, index + 1)) as string;
-        if (keys.has(key)) return key;
-        keys.add(key);
-        expectKey = false;
-      }
-      continue;
-    }
-    if (char === "{") {
-      depth += 1;
-      if (depth === 1) expectKey = true;
-    } else if (char === "}") {
-      depth -= 1;
-    } else if (char === "," && depth === 1) {
-      expectKey = true;
-    }
-  }
-  return undefined;
-};
+const RawBindingsSchema = Schema.fromJsonString(
+  Schema.Record(Schema.String, TableIdentifierSchema),
+);
 
 const asError = (cause: unknown): Error =>
   cause instanceof Error ? cause : new Error(String(cause));
@@ -69,64 +32,12 @@ const asError = (cause: unknown): Error =>
 const fail = (code: "TABLE_BINDINGS_INVALID" | "TABLE_BINDINGS_MISMATCH", message: string) =>
   new RuntimeConfigError({ code, message, cause: new Error(message) });
 
-const isRecord = (value: unknown): value is Record<string, unknown> =>
-  typeof value === "object" && value !== null && !Array.isArray(value);
-
-const hasExactKeys = (value: Record<string, unknown>, allowed: ReadonlyArray<string>) => {
-  const keys = Object.keys(value);
-  return (
-    keys.length === allowed.filter((key) => key in value).length &&
-    keys.every((key) => allowed.includes(key))
-  );
-};
-
-const nonEmptyName = (value: unknown): string => {
-  if (typeof value !== "string" || value.length === 0 || value.trim() !== value) {
-    throw fail("TABLE_BINDINGS_INVALID", "Table binding names must be non-empty strings");
-  }
-  return value;
-};
-
-const resolveBinding = (input: unknown): Effect.Effect<ResolvedTableBinding, RuntimeConfigError> =>
-  Effect.gen(function* () {
-    const binding = yield* Effect.try({
-      try: () => {
-        if (typeof input === "string") return { name: nonEmptyName(input) } as const;
-        if (!isRecord(input) || !hasExactKeys(input, ["name", "partition"])) {
-          throw fail(
-            "TABLE_BINDINGS_INVALID",
-            "Table bindings must be a name string or an object containing name and optional partition",
-          );
-        }
-        return { name: nonEmptyName(input.name), partition: input.partition } as const;
-      },
-      catch: (cause) =>
-        cause instanceof RuntimeConfigError
-          ? cause
-          : fail("TABLE_BINDINGS_INVALID", "Hosted table binding is invalid"),
-    });
-    if (!("partition" in binding) || binding.partition === undefined) {
-      return { name: binding.name };
-    }
-    const partitionValue = yield* Wings.PartitionValue.decodeJson(binding.partition).pipe(
-      Effect.mapError(
-        (cause) =>
-          new RuntimeConfigError({
-            code: "TABLE_BINDINGS_INVALID",
-            message: "Hosted table binding has an invalid partition value",
-            cause,
-          }),
-      ),
-    );
-    return { name: binding.name, partitionValue };
-  });
-
-/** Loads and validates the complete hosted Wings table map for a connector. */
-export const loadTableBindings = <const Connector extends ConnectorDefinition>(
-  connector: Connector,
-): Effect.Effect<ResolvedTableBindings<Connector>, RuntimeConfigError> =>
+/** Reads hosted table bindings and checks they name resources of the connector. */
+export const loadTableBindings = <const Source extends BindingSource>(
+  connector: Source,
+): Effect.Effect<ResolvedTableBindings<Source>, RuntimeConfigError> =>
   Effect.gen(function* () {
-    const raw = yield* Config.nonEmptyString(PlatformRuntimeKey.tableBindings).pipe(
+    const raw = yield* Config.NonEmptyString(PlatformRuntimeKey.tableBindings).pipe(
       Effect.mapError(
         (cause) =>
           new RuntimeConfigError({
@@ -136,45 +47,48 @@ export const loadTableBindings = <const Connector extends ConnectorDefinition>(
           }),
       ),
     );
-    const duplicate = yield* Effect.try({
-      try: () => duplicateTopLevelKey(raw),
-      catch: (cause) =>
-        new RuntimeConfigError({
-          code: "TABLE_BINDINGS_INVALID",
-          message: "Hosted table bindings are not valid JSON",
-          cause: asError(cause),
-        }),
-    });
-    if (duplicate !== undefined) {
-      return yield* Effect.fail(
-        fail("TABLE_BINDINGS_INVALID", "Hosted table bindings contain a duplicate resource"),
-      );
-    }
-    const decoded = yield* Schema.decodeUnknownEffect(RawBindingsSchema)(raw).pipe(
+
+    const decoded = yield* Schema.decodeUnknownEffect(RawBindingsSchema)(raw, {
+      onExcessProperty: "error",
+    }).pipe(
       Effect.mapError(
         (cause) =>
           new RuntimeConfigError({
             code: "TABLE_BINDINGS_INVALID",
-            message: "Hosted table bindings are not valid JSON",
+            message: "Hosted table bindings are invalid",
             cause: asError(cause),
           }),
       ),
     );
-    // Starting with a partial map would leave some manifest resources unwired.
-    const expected = new Set(connector.resources.map((resource) => resource.name));
+
     const actual = Object.keys(decoded);
-    const missing = [...expected].filter((name) => !(name in decoded));
+    if (actual.length === 0) {
+      return yield* Effect.fail(
+        fail("TABLE_BINDINGS_INVALID", "Hosted table bindings name no resources"),
+      );
+    }
+
+    // Bindings come from the platform, resources from the connector. An unknown name
+    // means one of them is out of date, and we could write to the wrong table.
+    const expected = new Set(connector.resources.map((resource) => resource.name));
     const unknown = actual.filter((name) => !expected.has(name));
-    if (missing.length > 0 || unknown.length > 0) {
+    if (unknown.length > 0) {
       return yield* Effect.fail(
         fail(
           "TABLE_BINDINGS_MISMATCH",
-          `Hosted table bindings do not match connector resources (missing: ${missing.join(", ") || "none"}; unknown resources: ${unknown.length})`,
+          `Hosted table bindings name resources the connector doesn't have (${unknown.length})`,
         ),
       );
     }
-    const entries = yield* Effect.forEach(actual, (name) =>
-      resolveBinding(decoded[name]).pipe(Effect.map((binding) => [name, binding] as const)),
-    );
-    return Object.fromEntries(entries) as ResolvedTableBindings<Connector>;
+
+    return Object.fromEntries(
+      Object.entries(decoded).map(([resource, identifier]) => [
+        resource,
+        {
+          namespace: Array.from(identifier.namespace),
+          name: identifier.name,
+          ...(identifier.location === undefined ? {} : { location: identifier.location }),
+        },
+      ]),
+    ) as ResolvedTableBindings<Source>;
   });

package/src/state-store/layer-key-value-store.ts

@@ -1,5 +1,5 @@
 import { DateTime, Effect, Layer, Option, Schema } from "effect";
-import { KeyValueStore } from "effect/unstable/persistence";
+import { KeyValueStore } from "effect/persistence";
 
 import { ConnectorError } from "../errors";
 import { resourceComponentKey, resourceErrorKey } from "./keys";
@@ -33,8 +33,13 @@ const resourceErrorContext = (
   switch (operation) {
     case "fetch":
       return { source, operation, code: "fetch_failed", message: `${sourceName} fetch failed` };
-    case "publish":
-      return { source, operation, code: "publish_failed", message: `${sourceName} publish failed` };
+    case "ingest":
+      return {
+        source,
+        operation,
+        code: "ingest_failed",
+        message: `${sourceName} ingestion failed`,
+      };
     case "checkpoint":
       return {
         source,

package/src/state-store/layer-memory.ts

@@ -1,5 +1,5 @@
 import { Layer } from "effect";
-import { KeyValueStore } from "effect/unstable/persistence";
+import { KeyValueStore } from "effect/persistence";
 
 import type { StateStore } from "./service";
 

package/src/state-store/layer-sql.ts

@@ -1,6 +1,6 @@
 import { Config, Effect, Layer } from "effect";
-import { KeyValueStore } from "effect/unstable/persistence";
-import { SqlClient } from "effect/unstable/sql";
+import { KeyValueStore } from "effect/persistence";
+import { SqlClient } from "effect/sql";
 
 import type { StateStore } from "./service";
 
@@ -32,8 +32,8 @@ const scopedKeyValueStore = (connectorInstanceId: string) =>
 export const layerSql = (): Layer.Layer<StateStore, Config.ConfigError, SqlClient.SqlClient> =>
   Layer.unwrap(
     Config.all({
-      connectorInstanceId: Config.nonEmptyString(PlatformRuntimeKey.connectorInstanceId),
-      table: Config.nonEmptyString(PlatformRuntimeKey.stateTable).pipe(
+      connectorInstanceId: Config.NonEmptyString(PlatformRuntimeKey.connectorInstanceId),
+      table: Config.NonEmptyString(PlatformRuntimeKey.stateTable).pipe(
         Config.withDefault(PlatformRuntimeDefault.stateTable),
       ),
     }).pipe(

package/src/state-store/schema.ts

@@ -18,11 +18,11 @@ export const ChangesStateSchema = Schema.Struct({
 
 export const StateSourceSchema = Schema.Literals(["backfill", "changes"]);
 
-export const StateOperationSchema = Schema.Literals(["fetch", "publish", "checkpoint"]);
+export const StateOperationSchema = Schema.Literals(["fetch", "ingest", "checkpoint"]);
 
 export const StateErrorCodeSchema = Schema.Literals([
   "fetch_failed",
-  "publish_failed",
+  "ingest_failed",
   "checkpoint_failed",
 ]);
 

package/src/state-store/state.ts

@@ -1,16 +1,28 @@
-import type { Cursor, ResourceDefinition, ResourceState, SyncState } from "../core/types";
+import type {
+  ConnectorDefinition,
+  Cursor,
+  ResourceDefinition,
+  ResourceState,
+  SyncState,
+} from "../core/types";
 
 /** Normalizes a cursor value to its persisted/wire representation (never a Date). */
 export const normalizeCursor = (value: Cursor.Value): string | number =>
   value instanceof Date ? value.toISOString() : value;
 
+/** Whether a resource gets changes, from its own `changes` or the connector's feed. */
+export const hasChanges = (connector: ConnectorDefinition, resource: ResourceDefinition) =>
+  resource.changes !== undefined ||
+  (connector.changes?.resources.some((member) => member.name === resource.name) ?? false);
+
 /** Derives connector-facing sync state from durable state and resource capabilities. */
 export const deriveSyncState = (
+  connector: ConnectorDefinition,
   resource: ResourceDefinition,
   state: ResourceState | undefined,
 ): SyncState => {
   if (state?.lastError) return "error";
-  if (!resource.backfill && !resource.changes) return "live";
+  if (!resource.backfill && !hasChanges(connector, resource)) return "live";
   if (!state) return "pending";
   if (resource.backfill && (!state.backfill || !state.backfill.completed)) return "backfilling";
   return "live";

package/src/status/route.ts

@@ -1,5 +1,5 @@
 import { Cause, Effect } from "effect";
-import { HttpRouter, HttpServerResponse } from "effect/unstable/http";
+import { HttpRouter, HttpServerResponse } from "effect/http";
 
 import type { ConnectorDefinition } from "../core/types";
 import type { ResourceStatus, StatusUnavailableResponse } from "./types";
@@ -24,7 +24,7 @@ export const statusRoute = (
             Effect.map(
               (state): ResourceStatus => ({
                 name: resource.name,
-                state: deriveSyncState(resource, state),
+                state: deriveSyncState(connector, resource, state),
                 ...(state?.backfill
                   ? {
                       backfill: {

package/src/telemetry.ts

@@ -1,6 +1,6 @@
-import { Cause, Config, Effect, Layer, Metric, Option, type Duration } from "effect";
-import { Headers } from "effect/unstable/http";
-import * as Observability from "effect/unstable/observability";
+import { Cause, Config, Effect, Layer, Metric, Option, Schema, type Duration } from "effect";
+import { Headers } from "effect/http";
+import * as Observability from "effect/observability";
 
 import { PlatformRuntimeKey } from "./runtime-config/constants";
 
@@ -9,7 +9,7 @@ export const SpanName = {
   batchProcess: "connector.batch.process",
   webhookDecode: "connector.webhook.decode",
   webhookHandle: "connector.webhook.handle",
-  publish: "connector.publish",
+  ingest: "connector.ingest",
   stateSet: "connector.state.set",
   apiFetch: "connector.api.fetch",
 } as const;
@@ -20,13 +20,13 @@ export const Attr = {
   connectorResourcesCount: "airfoil.connector.resources.count",
   resourceName: "airfoil.resource.name",
   resourceSource: "airfoil.resource.source",
-  batchMutations: "airfoil.batch.mutations",
+  batchRows: "airfoil.batch.rows",
   batchOutcome: "airfoil.batch.outcome",
   webhookPath: "airfoil.webhook.path",
   webhookOutcome: "airfoil.webhook.outcome",
   syncState: "airfoil.connector.sync.state",
   apiRetryReason: "airfoil.connector.api.retry.reason",
-  publisherSuccess: "airfoil.publisher.success",
+  ingestionSuccess: "airfoil.ingestion.success",
   stateKey: "airfoil.state.key",
   apiPath: "airfoil.api.path",
   errorPhase: "airfoil.error.phase",
@@ -58,9 +58,16 @@ const isRecord = (value: unknown): value is Record<string, unknown> =>
 const maxErrorMessageLength = 500;
 
 const OtlpEnvConfig = Config.all({
-  enabled: Config.boolean(PlatformRuntimeKey.otelEnabled).pipe(Config.withDefault(false)),
-  baseUrl: Config.option(Config.string(PlatformRuntimeKey.otelExporterOtlpEndpoint)),
-  rawHeaders: Config.option(Config.string(PlatformRuntimeKey.otelExporterOtlpHeaders)),
+  enabled: Config.Boolean(PlatformRuntimeKey.otelEnabled).pipe(Config.withDefault(false)),
+  baseUrl: Config.option(Config.String(PlatformRuntimeKey.otelExporterOtlpEndpoint)),
+  headers: Config.option(
+    Config.Record(
+      Schema.String,
+      Schema.StringFromUriComponent,
+      PlatformRuntimeKey.otelExporterOtlpHeaders,
+      { trim: true },
+    ),
+  ),
 });
 
 const defaultRedactedHeaders: ReadonlyArray<string | RegExp> = [
@@ -74,19 +81,6 @@ const defaultRedactedHeaders: ReadonlyArray<string | RegExp> = [
   /token/i,
 ];
 
-const parseOtelHeaders = (value: string): Record<string, string> =>
-  Object.fromEntries(
-    value
-      .split(",")
-      .map((entry) => entry.trim())
-      .filter(Boolean)
-      .flatMap((entry) => {
-        const separator = entry.indexOf("=");
-        if (separator < 1) return [];
-        return [[entry.slice(0, separator).trim(), entry.slice(separator + 1).trim()]];
-      }),
-  );
-
 const appendPath = (baseUrl: string, path: string) =>
   `${baseUrl.replace(/\/$/, "")}/${path.replace(/^\//, "")}`;
 
@@ -223,8 +217,8 @@ export const layer = (config: OtlpTracingConfig = {}, options: OtlpTracingOption
  *
  * @example
  * Telemetry.layerConfig({
- *   enabled: Config.boolean("MY_OTEL_ENABLED"),
- *   endpoint: Config.string("MY_COLLECTOR_URL"),
+ *   enabled: Config.Boolean("MY_OTEL_ENABLED"),
+ *   endpoint: Config.String("MY_COLLECTOR_URL"),
  * })
  */
 export const layerConfig = (
@@ -254,9 +248,7 @@ export const layerOtlpTracing = (options: OtlpTracingOptions = {}) =>
         {
           enabled: raw.enabled,
           endpoint: Option.getOrUndefined(raw.baseUrl),
-          headers: Option.isSome(raw.rawHeaders)
-            ? parseOtelHeaders(raw.rawHeaders.value)
-            : undefined,
+          headers: Option.getOrUndefined(raw.headers),
         },
         options,
       );
@@ -276,7 +268,7 @@ export const layerOtlpMetrics = (options: OtlpMetricsOptions = {}) =>
         );
       return Observability.OtlpMetrics.layer({
         url: appendPath(endpoint, "/v1/metrics"),
-        headers: Option.isSome(raw.rawHeaders) ? parseOtelHeaders(raw.rawHeaders.value) : undefined,
+        headers: Option.getOrUndefined(raw.headers),
         exportInterval: options.exportInterval,
         temporality: "cumulative",
       }).pipe(Layer.provide(Observability.OtlpSerialization.layerJson));

package/src/webhook/server.ts

@@ -1,18 +1,16 @@
 import { Cause, Context, Effect, Queue, Schema } from "effect";
-import { HttpRouter, HttpServerRequest, HttpServerResponse } from "effect/unstable/http";
+import { HttpRouter, HttpServerRequest, HttpServerResponse } from "effect/http";
 
 import type {
   ResourceBatch,
   ResourceDefinition,
-  ResourceMutation,
-  WebhookHandler,
   WebhookRoute,
   WebhookRouteContext,
 } from "../core/types";
 
 import { ConnectorError } from "../errors";
+import { ingestBatch } from "../ingestor/instrumented";
 import * as Metrics from "../metrics";
-import { publishBatch } from "../publisher/instrumented";
 import { Attr, SpanName, annotateError } from "../telemetry";
 
 export type QueuedWebhookBatch = {
@@ -27,39 +25,23 @@ export class WebhookQueue extends Context.Service<
   }
 >()("@useairfoil/connector-kit/WebhookQueue") {}
 
-const resourceBatch = <Row extends object>(
-  mutations: ReadonlyArray<ResourceMutation<Row>>,
-): ResourceBatch<Row> => ({
-  mutations,
+const resourceBatch = <Row extends object>(rows: ReadonlyArray<Row>): ResourceBatch<Row> => ({
+  rows,
 });
 
-const decodeAndHandleWebhook = <Row extends object, Payload>(
-  resourceName: string,
-  webhook: WebhookHandler<Row, Payload>,
-  payload: unknown,
-) =>
-  Schema.decodeUnknownEffect(webhook.schema)(payload).pipe(
-    Effect.mapError(
-      (cause) =>
-        new ConnectorError({
-          message: `Invalid webhook payload for resource ${resourceName}`,
-          cause,
-        }),
-    ),
-    Effect.flatMap((decoded) => webhook.handler({ payload: decoded })),
-  );
-
 const makeRouteContext = (
   request: HttpServerRequest.HttpServerRequest,
   rawBody: Uint8Array,
   payload: unknown,
   batches: Array<QueuedWebhookBatch>,
+  resourceNames: ReadonlyArray<string>,
 ): WebhookRouteContext<ReadonlyArray<ResourceDefinition>, unknown> => ({
   request,
   rawBody,
   payload,
   to: (resource, payload) =>
     Effect.gen(function* () {
+      if (!resourceNames.includes(resource.name)) return;
       if (!resource.webhook) {
         return yield* Effect.fail(
           new ConnectorError({
@@ -68,27 +50,28 @@ const makeRouteContext = (
         );
       }
 
-      const mutations = yield* decodeAndHandleWebhook(resource.name, resource.webhook, payload);
+      // The route already decoded the payload, so don't decode it again.
+      const rows = yield* resource.webhook.handler({ payload });
       batches.push({
         resource: resource.name,
-        batch: resourceBatch(mutations),
+        batch: resourceBatch(rows),
       });
     }),
 });
 
 const compactBatches = (batches: ReadonlyArray<QueuedWebhookBatch>) => {
-  const grouped = new Map<string, ResourceMutation[]>();
+  const grouped = new Map<string, object[]>();
   for (const item of batches) {
     const current = grouped.get(item.resource) ?? [];
-    grouped.set(item.resource, [...current, ...item.batch.mutations]);
+    grouped.set(item.resource, [...current, ...item.batch.rows]);
   }
-  return Array.from(grouped.entries()).map(([resource, mutations]) => ({
+  return Array.from(grouped.entries()).map(([resource, rows]) => ({
     resource,
-    batch: resourceBatch(mutations),
+    batch: resourceBatch(rows),
   }));
 };
 
-const publishBatches = (
+const ingestBatches = (
   batches: ReadonlyArray<QueuedWebhookBatch>,
   options: { readonly connectorName: string },
 ) =>
@@ -96,7 +79,7 @@ const publishBatches = (
     yield* Effect.forEach(
       batches,
       (batch) =>
-        publishBatch({
+        ingestBatch({
           connector: options.connectorName,
           resource: batch.resource,
           source: "webhook",
@@ -118,7 +101,13 @@ const parseJson = (rawBody: Uint8Array) =>
     catch: (cause) => new ConnectorError({ message: "Invalid webhook JSON", cause }),
   });
 
-const makeHandler = (route: WebhookRoute, options: { readonly connectorName: string }) =>
+type RouterOptions = {
+  readonly connectorName: string;
+  /** Events for other resources are skipped. */
+  readonly resourceNames: ReadonlyArray<string>;
+};
+
+const makeHandler = (route: WebhookRoute, options: RouterOptions) =>
   Effect.gen(function* () {
     const request = yield* HttpServerRequest.HttpServerRequest;
     const collected: Array<QueuedWebhookBatch> = [];
@@ -129,6 +118,7 @@ const makeHandler = (route: WebhookRoute, options: { readonly connectorName: str
         onSuccess: (value) => ({ _tag: "Success" as const, value }),
       }),
     );
+
     if (rawBodyResult._tag === "Error") {
       yield* Metrics.recordWebhookRequest({
         connector: options.connectorName,
@@ -144,6 +134,7 @@ const makeHandler = (route: WebhookRoute, options: { readonly connectorName: str
         onSuccess: (value) => ({ _tag: "Success" as const, value }),
       }),
     );
+
     if (jsonResult._tag === "Error") {
       yield* Metrics.recordWebhookRequest({
         connector: options.connectorName,
@@ -159,6 +150,7 @@ const makeHandler = (route: WebhookRoute, options: { readonly connectorName: str
         onSuccess: (value) => ({ _tag: "Success" as const, value }),
       }),
     );
+
     if (payloadResult._tag === "Error") {
       yield* Metrics.recordWebhookRequest({
         connector: options.connectorName,
@@ -170,7 +162,15 @@ const makeHandler = (route: WebhookRoute, options: { readonly connectorName: str
 
     const response = yield* Effect.withSpan(
       route
-        .handler(makeRouteContext(request, rawBodyResult.value, payloadResult.value, collected))
+        .handler(
+          makeRouteContext(
+            request,
+            rawBodyResult.value,
+            payloadResult.value,
+            collected,
+            options.resourceNames,
+          ),
+        )
         .pipe(Effect.tapError((error) => annotateError("webhook_handle", error))),
       SpanName.webhookHandle,
       { attributes: { [Attr.webhookPath]: route.path } },
@@ -188,12 +188,13 @@ const makeHandler = (route: WebhookRoute, options: { readonly connectorName: str
         path: String(route.path),
         outcome: response.status >= 400 ? "rejected" : "ok",
       });
+
       return response;
     }
 
     yield* Effect.withSpan(
-      publishBatches(batches, { connectorName: options.connectorName }).pipe(
-        Effect.tapError((error) => annotateError("webhook_publish", error)),
+      ingestBatches(batches, { connectorName: options.connectorName }).pipe(
+        Effect.tapError((error) => annotateError("webhook_ingest", error)),
       ),
       SpanName.webhookHandle,
       { attributes: { [Attr.webhookPath]: route.path } },
@@ -204,6 +205,7 @@ const makeHandler = (route: WebhookRoute, options: { readonly connectorName: str
       path: String(route.path),
       outcome: response.status >= 400 ? "rejected" : "ok",
     });
+
     return response;
   }).pipe(
     Effect.catchCause((cause) =>
@@ -225,10 +227,7 @@ const makeHandler = (route: WebhookRoute, options: { readonly connectorName: str
     ),
   );
 
-export const router = (
-  routes: ReadonlyArray<WebhookRoute>,
-  options: { readonly connectorName: string },
-) =>
+export const router = (routes: ReadonlyArray<WebhookRoute>, options: RouterOptions) =>
   HttpRouter.addAll(
     routes.map((route) => HttpRouter.route("POST", route.path, makeHandler(route, options))),
   );

package/dist/auth/index.d.ts

@@ -1,2 +0,0 @@
-import { i as makeTokenCache, n as ExpiringToken, r as TokenCache } from "../index-DXa26Ry5.js";
-export { ExpiringToken, TokenCache, makeTokenCache };

package/dist/auth/index.js

@@ -1,3 +0,0 @@
-import { n as makeTokenCache } from "../auth-DvU_CZ7C.js";
-
-export { makeTokenCache };

package/dist/auth-DvU_CZ7C.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"auth-DvU_CZ7C.js","names":[],"sources":["../src/auth/token-cache.ts","../src/auth/index.ts"],"sourcesContent":["import { Cache, Duration, Effect, Exit, Number, Redacted } from \"effect\";\n\nexport interface ExpiringToken {\n  /** The credential kept in memory by the cache. */\n  readonly value: Redacted.Redacted<string>;\n  /** The lifetime reported by the provider. */\n  readonly expiresIn: Duration.Duration;\n}\n\nexport interface TokenCache<E> {\n  /** Returns the cached token or performs one shared acquisition. */\n  readonly get: Effect.Effect<Redacted.Redacted<string>, E>;\n  /** Removes the cached token so the next `get` reacquires it. */\n  readonly invalidate: Effect.Effect<void>;\n}\n\n/**\n * Creates a lazy, in-memory token cache around an acquisition effect.\n *\n * `refreshFactor` controls how much of the provider lifetime is cached. It is\n * clamped between `0` and `1`.\n *\n * @example\n * ```ts\n * const cache = yield* makeTokenCache({\n *   acquire: exchangeCredentials,\n *   refreshFactor: 0.5,\n * })\n *\n * const token = yield* cache.get\n * ```\n */\nexport const makeTokenCache = <E, R>(options: {\n  readonly acquire: Effect.Effect<ExpiringToken, E, R>;\n  readonly refreshFactor?: number;\n}): Effect.Effect<TokenCache<E>, never, R> =>\n  Effect.gen(function* () {\n    const refreshFactor = Number.clamp(options.refreshFactor ?? 0.5, {\n      minimum: 0,\n      maximum: 1,\n    });\n    const cache = yield* Cache.makeWith((_: void) => options.acquire, {\n      capacity: 1,\n      timeToLive: (exit) =>\n        Exit.isSuccess(exit)\n          ? Duration.millis(Duration.toMillis(exit.value.expiresIn) * refreshFactor)\n          : Duration.zero,\n    });\n\n    return {\n      get: Cache.get(cache, undefined).pipe(Effect.map((token) => token.value)),\n      invalidate: Cache.invalidate(cache, undefined),\n    };\n  });\n","export * from \"./token-cache\";\n"],"mappings":";;;;;;;;;;;;;;;;;;;;AAgCA,MAAa,kBAAwB,YAInC,OAAO,IAAI,aAAa;CACtB,MAAM,gBAAgB,OAAO,MAAM,QAAQ,iBAAiB,IAAK;EAC/D,SAAS;EACT,SAAS;EACV,CAAC;CACF,MAAM,QAAQ,OAAO,MAAM,UAAU,MAAY,QAAQ,SAAS;EAChE,UAAU;EACV,aAAa,SACX,KAAK,UAAU,KAAK,GAChB,SAAS,OAAO,SAAS,SAAS,KAAK,MAAM,UAAU,GAAG,cAAc,GACxE,SAAS;EAChB,CAAC;AAEF,QAAO;EACL,KAAK,MAAM,IAAI,OAAO,OAAU,CAAC,KAAK,OAAO,KAAK,UAAU,MAAM,MAAM,CAAC;EACzE,YAAY,MAAM,WAAW,OAAO,OAAU;EAC/C;EACD"}