@useairfoil/connector-kit 0.4.0 → 0.5.1

package/dist/auth-DvU_CZ7C.js

@@ -0,0 +1,42 @@
+import { t as __export } from "./chunk-Bp6m_JJh.js";
+import { Cache, Duration, Effect, Exit, Number, Redacted } from "effect";
+
+//#region src/auth/token-cache.ts
+/**
+* Creates a lazy, in-memory token cache around an acquisition effect.
+*
+* `refreshFactor` controls how much of the provider lifetime is cached. It is
+* clamped between `0` and `1`.
+*
+* @example
+* ```ts
+* const cache = yield* makeTokenCache({
+*   acquire: exchangeCredentials,
+*   refreshFactor: 0.5,
+* })
+*
+* const token = yield* cache.get
+* ```
+*/
+const makeTokenCache = (options) => Effect.gen(function* () {
+	const refreshFactor = Number.clamp(options.refreshFactor ?? .5, {
+		minimum: 0,
+		maximum: 1
+	});
+	const cache = yield* Cache.makeWith((_) => options.acquire, {
+		capacity: 1,
+		timeToLive: (exit) => Exit.isSuccess(exit) ? Duration.millis(Duration.toMillis(exit.value.expiresIn) * refreshFactor) : Duration.zero
+	});
+	return {
+		get: Cache.get(cache, void 0).pipe(Effect.map((token) => token.value)),
+		invalidate: Cache.invalidate(cache, void 0)
+	};
+});
+
+//#endregion
+//#region src/auth/index.ts
+var auth_exports = /* @__PURE__ */ __export({ makeTokenCache: () => makeTokenCache });
+
+//#endregion
+export { makeTokenCache as n, auth_exports as t };
+//# sourceMappingURL=auth-DvU_CZ7C.js.map

package/dist/auth-DvU_CZ7C.js.map

@@ -0,0 +1 @@
+{"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"}

package/dist/chunk-Bp6m_JJh.js

@@ -0,0 +1,13 @@
+//#region rolldown:runtime
+var __defProp = Object.defineProperty;
+var __export = (all) => {
+	let target = {};
+	for (var name in all) __defProp(target, name, {
+		get: all[name],
+		enumerable: true
+	});
+	return target;
+};
+
+//#endregion
+export { __export as t };

package/dist/connector-app/index.d.ts

@@ -0,0 +1,14 @@
+import "../index-CTHVudvQ.js";
+import "../index-D54ySAKn.js";
+import "../types-B35J5YPu.js";
+import { d as CheckResult, f as ResourceCheckResult, i as start, n as App, p as check, r as StartOptions, u as CheckOptions } from "../index-DtJX_tic.js";
+import "../service-IE5qaf9x.js";
+import "../index-Coh_SkBs.js";
+import "../index-J42AZaXU.js";
+import "../index-CBT-JX-T.js";
+import "../metrics-CVAk1ALR.js";
+import "../index-Byr0Lf0C.js";
+import "../index-o1-Z3n7V.js";
+import "../index-CTLYQ74P.js";
+import "../index-fIIBVAai.js";
+export { App, CheckOptions, CheckResult, ResourceCheckResult, StartOptions, check, start };

package/dist/connector-app/index.js

@@ -0,0 +1,11 @@
+import "../errors-DHWylqRZ.js";
+import { n as start, r as check } from "../connector-app-d7Z-SZLQ.js";
+import "../metrics-CWPy2Aqc.js";
+import "../constants-BRhIX_rz.js";
+import "../service-DuFiQwid.js";
+import "../server-CXTQ7odl.js";
+import "../state-store-yl6LiTQ0.js";
+import "../status-B-oZBc33.js";
+import "../ingestion-BQo4cbGw.js";
+
+export { check, start };

package/dist/connector-app-d7Z-SZLQ.js

@@ -0,0 +1,64 @@
+import { t as __export } from "./chunk-Bp6m_JJh.js";
+import { n as run } from "./ingestion-BQo4cbGw.js";
+import { Context, DateTime, Effect, Layer, Tuple } from "effect";
+import { NodeHttpServer } from "@effect/platform-node";
+import { HttpRouter } from "effect/unstable/http";
+import { createServer } from "node:http";
+
+//#region src/connector-app/check.ts
+const ok = { _tag: "ok" };
+const error = (message) => ({
+	_tag: "error",
+	message
+});
+const fromEntries = (entries) => Object.fromEntries(entries);
+const resultsFor = (names, result) => fromEntries(names.map((name) => Tuple.make(name, result)));
+/**
+* Builds the connector service from its layer and validates only the selected
+* resources. The layer remains open until every check finishes.
+*/
+function check(service, layer, options) {
+	if (options.resources.length === 0) return Effect.succeed(fromEntries([]));
+	return service.pipe(Effect.flatMap((connector) => Effect.forEach(options.resources, (name) => {
+		const resource = connector.resources.find((candidate) => candidate.name === name);
+		return (resource ? resource.check.pipe(Effect.match({
+			onFailure: (failure) => error(failure.message),
+			onSuccess: () => ok
+		})) : Effect.succeed(error(`Unknown connector resource: ${name}`))).pipe(Effect.map((result) => Tuple.make(name, result)));
+	}).pipe(Effect.map(fromEntries))), Effect.provide(layer), Effect.match({
+		onFailure: (failure) => resultsFor(options.resources, error(failure.message)),
+		onSuccess: (results) => results
+	}));
+}
+
+//#endregion
+//#region src/connector-app/start.ts
+const start = (app, options) => Effect.gen(function* () {
+	const initialCutoff = options.initialCutoff ?? (yield* DateTime.now.pipe(Effect.map(DateTime.formatIso)));
+	const routes = app.webhooks?.map((route) => route.path) ?? [];
+	yield* Effect.logInfo("webhook server ready").pipe(Effect.annotateLogs({
+		port: options.port,
+		routes
+	}));
+	return yield* run(app, {
+		initialCutoff,
+		webhook: {
+			routes: app.webhooks ?? [],
+			healthPath: options.healthPath ?? "/health",
+			metricsPath: options.metricsPath,
+			statusPath: options.statusPath,
+			disableHttpLogger: options.disableHttpLogger ?? true
+		}
+	}).pipe(Effect.provide(NodeHttpServer.layer(createServer, { port: options.port })));
+});
+
+//#endregion
+//#region src/connector-app/index.ts
+var connector_app_exports = /* @__PURE__ */ __export({
+	check: () => check,
+	start: () => start
+});
+
+//#endregion
+export { start as n, check as r, connector_app_exports as t };
+//# sourceMappingURL=connector-app-d7Z-SZLQ.js.map

package/dist/connector-app-d7Z-SZLQ.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"connector-app-d7Z-SZLQ.js","names":["ok: ResourceCheckResult","runIngestion"],"sources":["../src/connector-app/check.ts","../src/connector-app/start.ts","../src/connector-app/index.ts"],"sourcesContent":["import { Context, Effect, Layer, Tuple } from \"effect\";\n\nimport type { ConnectorDefinition, ResourceDefinition, ResourceName } from \"../core/types\";\n\nexport type ResourceCheckResult =\n  | { readonly _tag: \"ok\" }\n  | { readonly _tag: \"error\"; readonly message: string };\n\nexport type CheckOptions<Name extends string> = {\n  readonly resources: ReadonlyArray<Name>;\n};\n\ntype ResourceCheckResults<Name extends PropertyKey> = {\n  readonly [Key in Name]: ResourceCheckResult;\n};\n\nexport type CheckResult<\n  Resources extends ReadonlyArray<ResourceDefinition>,\n  Name extends ResourceName<Resources> = ResourceName<Resources>,\n> = ResourceCheckResults<Name>;\n\ntype CheckFailure = { readonly message: string };\n\nconst ok: ResourceCheckResult = { _tag: \"ok\" };\n\nconst error = (message: string): ResourceCheckResult => ({ _tag: \"error\", message });\n\nconst fromEntries = <Name extends string>(\n  entries: ReadonlyArray<readonly [Name, ResourceCheckResult]>,\n): ResourceCheckResults<Name> => Object.fromEntries(entries) as ResourceCheckResults<Name>;\n\nconst resultsFor = <Name extends string>(names: ReadonlyArray<Name>, result: ResourceCheckResult) =>\n  fromEntries(names.map((name) => Tuple.make(name, result)));\n\n/**\n * Builds the connector service from its layer and validates only the selected\n * resources. The layer remains open until every check finishes.\n */\nexport function check<\n  Identifier,\n  const Resources extends ReadonlyArray<ResourceDefinition>,\n  E extends CheckFailure,\n  R,\n  const Name extends ResourceName<Resources>,\n>(\n  service: Context.Key<Identifier, ConnectorDefinition<Resources>>,\n  layer: Layer.Layer<Identifier, E, R>,\n  options: CheckOptions<Name>,\n): Effect.Effect<CheckResult<Resources, Name>, never, R> {\n  if (options.resources.length === 0) {\n    return Effect.succeed(fromEntries<Name>([]));\n  }\n\n  return service.pipe(\n    Effect.flatMap((connector) =>\n      Effect.forEach(options.resources, (name) => {\n        const resource = connector.resources.find((candidate) => candidate.name === name);\n        const result = resource\n          ? resource.check.pipe(\n              Effect.match({\n                onFailure: (failure) => error(failure.message),\n                onSuccess: () => ok,\n              }),\n            )\n          : Effect.succeed(error(`Unknown connector resource: ${name}`));\n\n        return result.pipe(Effect.map((result) => Tuple.make(name, result)));\n      }).pipe(Effect.map(fromEntries)),\n    ),\n    Effect.provide(layer),\n    Effect.match({\n      onFailure: (failure) => resultsFor(options.resources, error(failure.message)),\n      onSuccess: (results) => results,\n    }),\n  );\n}\n","import { NodeHttpServer } from \"@effect/platform-node\";\nimport { DateTime, Effect } from \"effect\";\nimport { HttpRouter } from \"effect/unstable/http\";\nimport { createServer } from \"node:http\";\n\nimport type { ConnectorDefinition } from \"../core\";\nimport type { Cursor } from \"../core/types\";\n\nimport { run as runIngestion } from \"../ingestion\";\n\nexport type App = ConnectorDefinition;\n\nexport type StartOptions = {\n  readonly port: number;\n  readonly initialCutoff?: Cursor.Value;\n  readonly healthPath?: HttpRouter.PathInput;\n  readonly metricsPath?: HttpRouter.PathInput | false;\n  readonly statusPath?: HttpRouter.PathInput | false;\n  readonly disableHttpLogger?: boolean;\n};\n\nexport const start = (app: App, options: StartOptions) =>\n  Effect.gen(function* () {\n    const initialCutoff =\n      options.initialCutoff ?? (yield* DateTime.now.pipe(Effect.map(DateTime.formatIso)));\n    const routes = app.webhooks?.map((route) => route.path) ?? [];\n\n    yield* Effect.logInfo(\"webhook server ready\").pipe(\n      Effect.annotateLogs({ port: options.port, routes }),\n    );\n\n    return yield* runIngestion(app, {\n      initialCutoff,\n      webhook: {\n        routes: app.webhooks ?? [],\n        healthPath: options.healthPath ?? \"/health\",\n        metricsPath: options.metricsPath,\n        statusPath: options.statusPath,\n        disableHttpLogger: options.disableHttpLogger ?? true,\n      },\n    }).pipe(Effect.provide(NodeHttpServer.layer(createServer, { port: options.port })));\n  });\n","export { check, type CheckOptions, type CheckResult, type ResourceCheckResult } from \"./check\";\nexport { start, type App, type StartOptions } from \"./start\";\n"],"mappings":";;;;;;;;AAuBA,MAAMA,KAA0B,EAAE,MAAM,MAAM;AAE9C,MAAM,SAAS,aAA0C;CAAE,MAAM;CAAS;CAAS;AAEnF,MAAM,eACJ,YAC+B,OAAO,YAAY,QAAQ;AAE5D,MAAM,cAAmC,OAA4B,WACnE,YAAY,MAAM,KAAK,SAAS,MAAM,KAAK,MAAM,OAAO,CAAC,CAAC;;;;;AAM5D,SAAgB,MAOd,SACA,OACA,SACuD;AACvD,KAAI,QAAQ,UAAU,WAAW,EAC/B,QAAO,OAAO,QAAQ,YAAkB,EAAE,CAAC,CAAC;AAG9C,QAAO,QAAQ,KACb,OAAO,SAAS,cACd,OAAO,QAAQ,QAAQ,YAAY,SAAS;EAC1C,MAAM,WAAW,UAAU,UAAU,MAAM,cAAc,UAAU,SAAS,KAAK;AAUjF,UATe,WACX,SAAS,MAAM,KACb,OAAO,MAAM;GACX,YAAY,YAAY,MAAM,QAAQ,QAAQ;GAC9C,iBAAiB;GAClB,CAAC,CACH,GACD,OAAO,QAAQ,MAAM,+BAA+B,OAAO,CAAC,EAElD,KAAK,OAAO,KAAK,WAAW,MAAM,KAAK,MAAM,OAAO,CAAC,CAAC;GACpE,CAAC,KAAK,OAAO,IAAI,YAAY,CAAC,CACjC,EACD,OAAO,QAAQ,MAAM,EACrB,OAAO,MAAM;EACX,YAAY,YAAY,WAAW,QAAQ,WAAW,MAAM,QAAQ,QAAQ,CAAC;EAC7E,YAAY,YAAY;EACzB,CAAC,CACH;;;;;ACrDH,MAAa,SAAS,KAAU,YAC9B,OAAO,IAAI,aAAa;CACtB,MAAM,gBACJ,QAAQ,kBAAkB,OAAO,SAAS,IAAI,KAAK,OAAO,IAAI,SAAS,UAAU,CAAC;CACpF,MAAM,SAAS,IAAI,UAAU,KAAK,UAAU,MAAM,KAAK,IAAI,EAAE;AAE7D,QAAO,OAAO,QAAQ,uBAAuB,CAAC,KAC5C,OAAO,aAAa;EAAE,MAAM,QAAQ;EAAM;EAAQ,CAAC,CACpD;AAED,QAAO,OAAOC,IAAa,KAAK;EAC9B;EACA,SAAS;GACP,QAAQ,IAAI,YAAY,EAAE;GAC1B,YAAY,QAAQ,cAAc;GAClC,aAAa,QAAQ;GACrB,YAAY,QAAQ;GACpB,mBAAmB,QAAQ,qBAAqB;GACjD;EACF,CAAC,CAAC,KAAK,OAAO,QAAQ,eAAe,MAAM,cAAc,EAAE,MAAM,QAAQ,MAAM,CAAC,CAAC,CAAC;EACnF"}

package/dist/constants-BRhIX_rz.js

@@ -0,0 +1,27 @@
+import { HashSet } from "effect";
+
+//#region src/runtime-config/constants.ts
+/** Shared runtime keys owned by Airfoil rather than an individual connector. */
+const PlatformRuntimeKey = {
+	configPath: "AIRFOIL_CONFIG_PATH",
+	connectorInstanceId: "AIRFOIL_CONNECTOR_INSTANCE_ID",
+	stateTable: "AIRFOIL_STATE_TABLE",
+	postgresConnectionString: "POSTGRES_CONNECTION_STRING",
+	wingsHost: "WINGS_HOST",
+	wingsNamespace: "WINGS_NAMESPACE",
+	otelEnabled: "OTEL_ENABLED",
+	otelExporterOtlpEndpoint: "OTEL_EXPORTER_OTLP_ENDPOINT",
+	otelExporterOtlpHeaders: "OTEL_EXPORTER_OTLP_HEADERS",
+	otelServiceName: "OTEL_SERVICE_NAME",
+	otelServiceVersion: "OTEL_SERVICE_VERSION",
+	otelResourceAttributes: "OTEL_RESOURCE_ATTRIBUTES"
+};
+/** Defaults for optional platform-owned runtime configuration. */
+const PlatformRuntimeDefault = { stateTable: "_airfoil_connectors_state" };
+const platformRuntimeKeys = HashSet.fromIterable(Object.values(PlatformRuntimeKey));
+/** @internal */
+const isPlatformRuntimeKey = (key) => HashSet.has(platformRuntimeKeys, key);
+
+//#endregion
+export { PlatformRuntimeKey as n, isPlatformRuntimeKey as r, PlatformRuntimeDefault as t };
+//# sourceMappingURL=constants-BRhIX_rz.js.map

package/dist/constants-BRhIX_rz.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"constants-BRhIX_rz.js","names":[],"sources":["../src/runtime-config/constants.ts"],"sourcesContent":["import { HashSet } from \"effect\";\n\n/** Shared runtime keys owned by Airfoil rather than an individual connector. */\nexport const PlatformRuntimeKey = {\n  configPath: \"AIRFOIL_CONFIG_PATH\",\n  connectorInstanceId: \"AIRFOIL_CONNECTOR_INSTANCE_ID\",\n  stateTable: \"AIRFOIL_STATE_TABLE\",\n  postgresConnectionString: \"POSTGRES_CONNECTION_STRING\",\n  wingsHost: \"WINGS_HOST\",\n  wingsNamespace: \"WINGS_NAMESPACE\",\n  otelEnabled: \"OTEL_ENABLED\",\n  otelExporterOtlpEndpoint: \"OTEL_EXPORTER_OTLP_ENDPOINT\",\n  otelExporterOtlpHeaders: \"OTEL_EXPORTER_OTLP_HEADERS\",\n  otelServiceName: \"OTEL_SERVICE_NAME\",\n  otelServiceVersion: \"OTEL_SERVICE_VERSION\",\n  otelResourceAttributes: \"OTEL_RESOURCE_ATTRIBUTES\",\n} as const;\n\n/** Defaults for optional platform-owned runtime configuration. */\nexport const PlatformRuntimeDefault = {\n  stateTable: \"_airfoil_connectors_state\",\n} as const;\n\nconst platformRuntimeKeys = HashSet.fromIterable(Object.values(PlatformRuntimeKey));\n\n/** @internal */\nexport const isPlatformRuntimeKey = (key: string): boolean => HashSet.has(platformRuntimeKeys, key);\n"],"mappings":";;;;AAGA,MAAa,qBAAqB;CAChC,YAAY;CACZ,qBAAqB;CACrB,YAAY;CACZ,0BAA0B;CAC1B,WAAW;CACX,gBAAgB;CAChB,aAAa;CACb,0BAA0B;CAC1B,yBAAyB;CACzB,iBAAiB;CACjB,oBAAoB;CACpB,wBAAwB;CACzB;;AAGD,MAAa,yBAAyB,EACpC,YAAY,6BACb;AAED,MAAM,sBAAsB,QAAQ,aAAa,OAAO,OAAO,mBAAmB,CAAC;;AAGnF,MAAa,wBAAwB,QAAyB,QAAQ,IAAI,qBAAqB,IAAI"}

package/dist/errors/index.d.ts

@@ -0,0 +1,2 @@
+import { t as ConnectorError } from "../index-D54ySAKn.js";
+export { ConnectorError };

package/dist/errors/index.js

@@ -0,0 +1,3 @@
+import { t as ConnectorError } from "../errors-DHWylqRZ.js";
+
+export { ConnectorError };

package/dist/errors-DHWylqRZ.js

@@ -0,0 +1,8 @@
+import { Data } from "effect";
+
+//#region src/errors/connector-error.ts
+var ConnectorError = class extends Data.TaggedError("ConnectorError") {};
+
+//#endregion
+export { ConnectorError as t };
+//# sourceMappingURL=errors-DHWylqRZ.js.map

package/dist/errors-DHWylqRZ.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"errors-DHWylqRZ.js","names":[],"sources":["../src/errors/connector-error.ts"],"sourcesContent":["import { Data } from \"effect\";\n\nexport class ConnectorError extends Data.TaggedError(\"ConnectorError\")<{\n  readonly message: string;\n  readonly cause?: unknown;\n}> {}\n"],"mappings":";;;AAEA,IAAa,iBAAb,cAAoC,KAAK,YAAY,iBAAiB,CAGnE"}

package/dist/index-Byr0Lf0C.d.ts

@@ -0,0 +1,25 @@
+import { t as ConnectorError } from "./index-D54ySAKn.js";
+import { c as ResourceBatch, n as ConnectorDefinition } from "./types-B35J5YPu.js";
+import { a as PublisherService, i as Publisher, n as PublishOptions, r as PublishSource, t as PublishAck } from "./service-IE5qaf9x.js";
+import { Layer } from "effect";
+import * as Wings from "@useairfoil/wings";
+
+//#region src/publisher/wings.d.ts
+type WingsTableMapping = {
+  readonly name: string;
+  readonly partitionValue?: Wings.PartitionValue.PartitionValue;
+};
+type WingsPublisherConfig = {
+  readonly connector: ConnectorDefinition;
+  readonly tables: Record<string, string | WingsTableMapping>;
+};
+declare const layerWings: (config: WingsPublisherConfig) => Layer.Layer<Publisher, ConnectorError, Wings.WingsClient.WingsClient>;
+//#endregion
+//#region src/publisher/console.d.ts
+declare const layerConsole: Layer.Layer<Publisher, never, never>;
+declare namespace index_d_exports {
+  export { PublishAck, PublishOptions, PublishSource, Publisher, PublisherService, ResourceBatch, WingsPublisherConfig, layerConsole, layerWings };
+}
+//#endregion
+export { layerWings as i, layerConsole as n, WingsPublisherConfig as r, index_d_exports as t };
+//# sourceMappingURL=index-Byr0Lf0C.d.ts.map

package/dist/index-CBT-JX-T.d.ts

@@ -0,0 +1,173 @@
+import { Config, Option, Redacted, Schema, Types } from "effect";
+import * as effect_Effect0 from "effect/Effect";
+
+//#region src/manifest/number-schema.d.ts
+type NumberConstraints = {
+  readonly integer?: boolean;
+  readonly minimum?: number;
+};
+//#endregion
+//#region src/manifest/config.d.ts
+type ConfigFieldSpecBase = {
+  readonly runtimeKey: string;
+  readonly required: boolean;
+  readonly description?: string;
+};
+type ConfigFieldDefinition = ConfigFieldSpecBase & ({
+  readonly type: "string";
+  readonly secret: false;
+  readonly default?: string;
+  readonly values?: never;
+} | {
+  readonly type: "string";
+  readonly secret: true;
+  readonly default?: never;
+  readonly values?: never;
+} | {
+  readonly type: "number";
+  readonly secret: false;
+  readonly default?: number;
+  readonly values?: never;
+  readonly integer?: boolean;
+  readonly minimum?: number;
+} | {
+  readonly type: "boolean";
+  readonly secret: false;
+  readonly default?: boolean;
+  readonly values?: never;
+} | {
+  readonly type: "select";
+  readonly secret: false;
+  readonly default?: string;
+  readonly values: readonly [string, ...Array<string>];
+});
+/** Serializable, browser-safe metadata for one user-provided connector setting. */
+type ConfigFieldSpec = ConfigFieldDefinition & {
+  readonly name: string;
+};
+/** Pairs an Effect runtime config with the metadata used to generate its form field. */
+type ConfigField<A$1> = {
+  readonly config: Config.Config<A$1>;
+  readonly spec: ConfigFieldDefinition;
+};
+type FieldBaseOptions = {
+  readonly runtimeKey: string;
+  readonly description?: string;
+};
+type FieldOptions<A$1 extends string | number | boolean = string | number | boolean> = FieldBaseOptions & ({
+  readonly required?: true;
+  readonly default?: A$1;
+} | {
+  readonly required: false;
+  readonly default: A$1;
+});
+type NumberFieldOptions = FieldOptions<number> & NumberConstraints;
+type FieldsRecord = Record<string, ConfigField<unknown>>;
+type ConfigOf<Fields$1 extends FieldsRecord> = { readonly [Key in keyof Fields$1]: Fields$1[Key] extends ConfigField<infer A> ? A : never };
+/** Effect config and serializable manifest metadata produced from one field definition. */
+type ConnectorConfigDef<Fields$1 extends FieldsRecord> = {
+  readonly fields: { readonly [Key in keyof Fields$1]: Fields$1[Key] extends ConfigField<infer A> ? Config.Config<A> : never };
+  readonly config: Config.Config<ConfigOf<Fields$1>>;
+  readonly spec: ReadonlyArray<ConfigFieldSpec>;
+};
+type ConfigValuesOf<Def extends ConnectorConfigDef<FieldsRecord>> = Def extends ConnectorConfigDef<infer Fields> ? ConfigOf<Fields> : never;
+/** Defines a required non-empty string, optionally with a default. */
+declare const string: (options: FieldOptions<string>) => ConfigField<string>;
+/** Defines a finite number with optional integer, minimum, and default constraints. */
+declare const number: (options: NumberFieldOptions) => ConfigField<number>;
+/** Defines a boolean, optionally with a default. */
+declare const boolean: (options: FieldOptions<boolean>) => ConfigField<boolean>;
+/** Defines a string literal choice whose values are preserved in the inferred type. */
+declare const select: <const Values extends readonly [string, ...Array<string>]>(options: FieldOptions<Values[number]> & {
+  readonly values: Values;
+}) => ConfigField<Values[number]>;
+/** Defines a required, non-empty secret decoded as `Redacted<string>`. */
+declare const secret: (options: FieldBaseOptions & {
+  readonly required?: true;
+}) => ConfigField<Redacted.Redacted<string>>;
+/** Makes an existing field optional and represents a missing value as `Option.none()`. */
+declare const optional: <A$1>(field: ConfigField<A$1>) => ConfigField<Option.Option<A$1>>;
+/**
+ * Defines user-facing connector config once for both Effect runtime loading and
+ * frontend form generation. The object keys become logical form/API field names;
+ * `runtimeKey` remains the key read by Effect Config.
+ *
+ * @example
+ * ```ts
+ * const config = define({
+ *   apiUrl: string({ runtimeKey: "API_URL" }),
+ *   token: secret({ runtimeKey: "API_TOKEN" }),
+ * });
+ *
+ * const RuntimeConfig = config.config;
+ * const formFields = config.spec;
+ * ```
+ */
+declare const define: <const Fields$1 extends FieldsRecord>(fields: Fields$1) => ConnectorConfigDef<Fields$1>;
+//#endregion
+//#region src/manifest/manifest.d.ts
+type ResourceCapability = "backfill" | "changes" | "webhook";
+/** Browser-safe connector metadata consumed by the platform and runtime adapters. */
+type ConnectorManifest = {
+  readonly name: string;
+  readonly title: string;
+  readonly description?: string;
+  readonly config: ReadonlyArray<ConfigFieldSpec>;
+  readonly resources: ReadonlyArray<{
+    readonly name: string;
+    readonly capabilities: ReadonlyArray<ResourceCapability>;
+  }>;
+};
+/**
+ * Defines browser-safe connector metadata while preserving literal names and capabilities.
+ *
+ * @example
+ * ```ts
+ * const manifest = define({
+ *   name: "producer-example",
+ *   title: "Example",
+ *   config: ExampleConfig.spec,
+ *   resources: [{ name: "orders", capabilities: ["backfill"] }],
+ * });
+ * ```
+ */
+declare const define$1: <const Manifest extends ConnectorManifest>(manifest: Manifest) => Manifest;
+//#endregion
+//#region src/manifest/schema.d.ts
+type FieldValueOf<Field$1 extends ConfigFieldSpec> = Field$1["type"] extends "number" ? number : Field$1["type"] extends "boolean" ? boolean : Field$1["values"] extends ReadonlyArray<string> ? Field$1["values"][number] : string;
+type ConnectorConfigValues<Manifest extends ConnectorManifest> = Types.Simplify<{ readonly [Field in Manifest["config"][number] as Field["required"] extends true ? Field["name"] : never]: FieldValueOf<Field> } & { readonly [Field in Manifest["config"][number] as Field["required"] extends true ? never : Field["name"]]?: FieldValueOf<Field> | undefined }> & object;
+type ConnectorConfigSchema<Manifest extends ConnectorManifest> = Schema.Codec<ConnectorConfigValues<Manifest>, unknown>;
+/** Flat primitive document keyed by the runtime keys consumed by Effect Config. */
+type RuntimeConfigDocument = Readonly<Record<string, string | number | boolean>>;
+/**
+ * Builds an Effect Schema for logical form/API values from a connector manifest.
+ *
+ * @example
+ * ```ts
+ * const decode = Schema.decodeUnknownEffect(configSchema(manifest));
+ * const values = decode({
+ *   apiUrl: "https://example.com",
+ *   retries: "3",
+ * });
+ * ```
+ */
+declare const configSchema: <const Manifest extends ConnectorManifest>(manifest: Manifest) => ConnectorConfigSchema<Manifest>;
+/** Decodes browser/API config, applies manifest defaults, and rejects undeclared fields. */
+declare const decodeConfig: <const Manifest extends ConnectorManifest>(manifest: Manifest, input: unknown) => effect_Effect0.Effect<ConnectorConfigValues<Manifest>, Schema.SchemaError, never>;
+/**
+ * Maps validated logical values to the flat runtime-key document mounted in a pod.
+ * Missing optional values are omitted.
+ *
+ * @example
+ * ```ts
+ * toRuntimeDocument(manifest, { apiUrl: "https://example.com" });
+ * // { API_URL: "https://example.com" }
+ * ```
+ */
+declare const toRuntimeDocument: <const Manifest extends ConnectorManifest>(manifest: Manifest, values: ConnectorConfigValues<Manifest>) => RuntimeConfigDocument;
+declare namespace index_d_exports {
+  export { ConfigField, ConfigFieldSpec, ConfigValuesOf, ConnectorConfigDef, ConnectorConfigSchema, ConnectorConfigValues, ConnectorManifest, ResourceCapability, RuntimeConfigDocument, boolean, configSchema, decodeConfig, define$1 as define, define as defineConfig, number, optional, secret, select, string, toRuntimeDocument };
+}
+//#endregion
+export { number as _, configSchema as a, select as b, ConnectorManifest as c, ConfigField as d, ConfigFieldSpec as f, define as g, boolean as h, RuntimeConfigDocument as i, ResourceCapability as l, ConnectorConfigDef as m, ConnectorConfigSchema as n, decodeConfig as o, ConfigValuesOf as p, ConnectorConfigValues as r, toRuntimeDocument as s, index_d_exports as t, define$1 as u, optional as v, string as x, secret as y };
+//# sourceMappingURL=index-CBT-JX-T.d.ts.map

package/dist/index-CTHVudvQ.d.ts

@@ -0,0 +1,41 @@
+import { Duration, Effect, Redacted } from "effect";
+
+//#region src/auth/token-cache.d.ts
+interface ExpiringToken {
+  /** The credential kept in memory by the cache. */
+  readonly value: Redacted.Redacted<string>;
+  /** The lifetime reported by the provider. */
+  readonly expiresIn: Duration.Duration;
+}
+interface TokenCache<E> {
+  /** Returns the cached token or performs one shared acquisition. */
+  readonly get: Effect.Effect<Redacted.Redacted<string>, E>;
+  /** Removes the cached token so the next `get` reacquires it. */
+  readonly invalidate: Effect.Effect<void>;
+}
+/**
+ * Creates a lazy, in-memory token cache around an acquisition effect.
+ *
+ * `refreshFactor` controls how much of the provider lifetime is cached. It is
+ * clamped between `0` and `1`.
+ *
+ * @example
+ * ```ts
+ * const cache = yield* makeTokenCache({
+ *   acquire: exchangeCredentials,
+ *   refreshFactor: 0.5,
+ * })
+ *
+ * const token = yield* cache.get
+ * ```
+ */
+declare const makeTokenCache: <E, R>(options: {
+  readonly acquire: Effect.Effect<ExpiringToken, E, R>;
+  readonly refreshFactor?: number;
+}) => Effect.Effect<TokenCache<E>, never, R>;
+declare namespace index_d_exports {
+  export { ExpiringToken, TokenCache, makeTokenCache };
+}
+//#endregion
+export { makeTokenCache as i, ExpiringToken as n, TokenCache as r, index_d_exports as t };
+//# sourceMappingURL=index-CTHVudvQ.d.ts.map

package/dist/index-CTLYQ74P.d.ts

@@ -0,0 +1,80 @@
+import { n as ConnectorDefinition } from "./types-B35J5YPu.js";
+import { i as StateStore } from "./index-Coh_SkBs.js";
+import { Schema } from "effect";
+import { HttpRouter } from "effect/unstable/http";
+import * as effect_Layer1 from "effect/Layer";
+
+//#region src/status/route.d.ts
+declare const statusRoute: (connector: ConnectorDefinition, path?: HttpRouter.PathInput) => effect_Layer1.Layer<never, never, HttpRouter.HttpRouter | HttpRouter.Request<"Requires", StateStore>>;
+//#endregion
+//#region src/status/types.d.ts
+declare const SyncStateSchema: Schema.Literals<readonly ["pending", "backfilling", "live", "error"]>;
+type SyncState = Schema.Schema.Type<typeof SyncStateSchema>;
+/** Safe source failure returned by the status endpoint. */
+declare const ResourceErrorSchema: Schema.Struct<{
+  readonly at: Schema.String;
+  readonly source: Schema.Literals<readonly ["backfill", "changes"]>;
+  readonly operation: Schema.Literals<readonly ["fetch", "publish", "checkpoint"]>;
+  readonly code: Schema.Literals<readonly ["fetch_failed", "publish_failed", "checkpoint_failed"]>;
+  readonly message: Schema.String;
+}>;
+type ResourceError = Schema.Schema.Type<typeof ResourceErrorSchema>;
+declare const ResourceStatusSchema: Schema.Struct<{
+  readonly backfill: Schema.optional<Schema.Struct<{
+    readonly cutoff: Schema.Union<readonly [Schema.String, Schema.Number]>;
+    readonly pageCursor: Schema.optional<Schema.Union<readonly [Schema.String, Schema.Number]>>;
+    readonly completed: Schema.Boolean;
+    readonly lastSuccessAt: Schema.optional<Schema.String>;
+  }>>;
+  readonly changes: Schema.optional<Schema.Struct<{
+    readonly cursor: Schema.Union<readonly [Schema.String, Schema.Number]>;
+    readonly lastSuccessAt: Schema.optional<Schema.String>;
+  }>>;
+  readonly lastError: Schema.optional<Schema.Struct<{
+    readonly at: Schema.String;
+    readonly source: Schema.Literals<readonly ["backfill", "changes"]>;
+    readonly operation: Schema.Literals<readonly ["fetch", "publish", "checkpoint"]>;
+    readonly code: Schema.Literals<readonly ["fetch_failed", "publish_failed", "checkpoint_failed"]>;
+    readonly message: Schema.String;
+  }>>;
+  readonly name: Schema.String;
+  readonly state: Schema.Literals<readonly ["pending", "backfilling", "live", "error"]>;
+}>;
+type ResourceStatus = Schema.Schema.Type<typeof ResourceStatusSchema>;
+declare const StatusResponseSchema: Schema.Struct<{
+  readonly connector: Schema.String;
+  readonly resources: Schema.$Array<Schema.Struct<{
+    readonly backfill: Schema.optional<Schema.Struct<{
+      readonly cutoff: Schema.Union<readonly [Schema.String, Schema.Number]>;
+      readonly pageCursor: Schema.optional<Schema.Union<readonly [Schema.String, Schema.Number]>>;
+      readonly completed: Schema.Boolean;
+      readonly lastSuccessAt: Schema.optional<Schema.String>;
+    }>>;
+    readonly changes: Schema.optional<Schema.Struct<{
+      readonly cursor: Schema.Union<readonly [Schema.String, Schema.Number]>;
+      readonly lastSuccessAt: Schema.optional<Schema.String>;
+    }>>;
+    readonly lastError: Schema.optional<Schema.Struct<{
+      readonly at: Schema.String;
+      readonly source: Schema.Literals<readonly ["backfill", "changes"]>;
+      readonly operation: Schema.Literals<readonly ["fetch", "publish", "checkpoint"]>;
+      readonly code: Schema.Literals<readonly ["fetch_failed", "publish_failed", "checkpoint_failed"]>;
+      readonly message: Schema.String;
+    }>>;
+    readonly name: Schema.String;
+    readonly state: Schema.Literals<readonly ["pending", "backfilling", "live", "error"]>;
+  }>>;
+}>;
+type StatusResponse = Schema.Schema.Type<typeof StatusResponseSchema>;
+/** Returned when durable resource status cannot be read. */
+declare const StatusUnavailableResponseSchema: Schema.Struct<{
+  readonly ok: Schema.Literal<false>;
+  readonly error: Schema.String;
+}>;
+type StatusUnavailableResponse = Schema.Schema.Type<typeof StatusUnavailableResponseSchema>;
+declare namespace index_d_exports {
+  export { ResourceError, ResourceErrorSchema, ResourceStatus, ResourceStatusSchema, StatusResponse, StatusResponseSchema, StatusUnavailableResponse, StatusUnavailableResponseSchema, SyncState, SyncStateSchema, statusRoute };
+}
+//#endregion
+export { ResourceStatusSchema as a, StatusUnavailableResponse as c, SyncStateSchema as d, statusRoute as f, ResourceStatus as i, StatusUnavailableResponseSchema as l, ResourceError as n, StatusResponse as o, ResourceErrorSchema as r, StatusResponseSchema as s, index_d_exports as t, SyncState as u };
+//# sourceMappingURL=index-CTLYQ74P.d.ts.map

package/dist/index-Coh_SkBs.d.ts

@@ -0,0 +1,95 @@
+import { t as ConnectorError } from "./index-D54ySAKn.js";
+import { Config, Context, Effect, Layer, Schema } from "effect";
+import { SqlClient } from "effect/unstable/sql";
+
+//#region src/state-store/schema.d.ts
+/** Durable progress for a finite historical backfill. */
+declare const BackfillStateSchema: Schema.Struct<{
+  readonly cutoff: Schema.Union<readonly [Schema.String, Schema.Number]>;
+  readonly pageCursor: Schema.optional<Schema.Union<readonly [Schema.String, Schema.Number]>>;
+  readonly completed: Schema.Boolean;
+  readonly lastSuccessAt: Schema.optional<Schema.String>;
+}>;
+/** Durable cursor for an ongoing incremental changes stream. */
+declare const ChangesStateSchema: Schema.Struct<{
+  readonly cursor: Schema.Union<readonly [Schema.String, Schema.Number]>;
+  readonly lastSuccessAt: Schema.optional<Schema.String>;
+}>;
+declare const StateSourceSchema: Schema.Literals<readonly ["backfill", "changes"]>;
+declare const StateOperationSchema: Schema.Literals<readonly ["fetch", "publish", "checkpoint"]>;
+/** Complete persisted state assembled from independently stored components. */
+declare const ResourceStateSchema: Schema.Struct<{
+  readonly backfill: Schema.optional<Schema.Struct<{
+    readonly cutoff: Schema.Union<readonly [Schema.String, Schema.Number]>;
+    readonly pageCursor: Schema.optional<Schema.Union<readonly [Schema.String, Schema.Number]>>;
+    readonly completed: Schema.Boolean;
+    readonly lastSuccessAt: Schema.optional<Schema.String>;
+  }>>;
+  readonly changes: Schema.optional<Schema.Struct<{
+    readonly cursor: Schema.Union<readonly [Schema.String, Schema.Number]>;
+    readonly lastSuccessAt: Schema.optional<Schema.String>;
+  }>>;
+  readonly lastError: Schema.optional<Schema.Struct<{
+    readonly at: Schema.String;
+    readonly source: Schema.Literals<readonly ["backfill", "changes"]>;
+    readonly operation: Schema.Literals<readonly ["fetch", "publish", "checkpoint"]>;
+    readonly code: Schema.Literals<readonly ["fetch_failed", "publish_failed", "checkpoint_failed"]>;
+    readonly message: Schema.String;
+  }>>;
+}>;
+type PersistedBackfillState = Schema.Schema.Type<typeof BackfillStateSchema>;
+type PersistedChangesState = Schema.Schema.Type<typeof ChangesStateSchema>;
+type StateSource = Schema.Schema.Type<typeof StateSourceSchema>;
+type StateOperation = Schema.Schema.Type<typeof StateOperationSchema>;
+type PersistedResourceState = Schema.Schema.Type<typeof ResourceStateSchema>;
+//#endregion
+//#region src/state-store/service.d.ts
+/** Connector-facing durable state operations, independent of the storage backend. */
+interface StateStoreService {
+  readonly getResourceState: (resource: string) => Effect.Effect<PersistedResourceState | undefined, ConnectorError>;
+  readonly setBackfillState: (resource: string, state: PersistedBackfillState) => Effect.Effect<void, ConnectorError>;
+  readonly setChangesState: (resource: string, state: PersistedChangesState) => Effect.Effect<void, ConnectorError>;
+  readonly setResourceError: (resource: string, source: StateSource, operation: StateOperation) => Effect.Effect<void, ConnectorError>;
+  readonly clearResourceError: (resource: string, source: StateSource) => Effect.Effect<void, ConnectorError>;
+}
+declare const StateStore_base: Context.ServiceClass<StateStore, "@useairfoil/connector-kit/StateStore", StateStoreService>;
+/**
+ * Effect service used by ingestion and status logic for connector checkpoints.
+ * Production provides `layerSql`; sandboxes and tests may provide `layerMemory`.
+ *
+ * @example
+ * ```ts
+ * const program = Effect.gen(function* () {
+ *   const state = yield* StateStore;
+ *   yield* state.setChangesState("orders", { cursor: "next-page" });
+ * });
+ * ```
+ */
+declare class StateStore extends StateStore_base {}
+//#endregion
+//#region src/state-store/layer-memory.d.ts
+/** Process-local state for tests and explicit local sandbox commands. */
+declare const layerMemory: Layer.Layer<StateStore>;
+//#endregion
+//#region src/state-store/layer-sql.d.ts
+/**
+ * Shared SQL state using the immutable connector instance ID supplied by
+ * platform-owned Effect configuration. The table defaults to
+ * `_airfoil_connectors_state` and can be overridden with `AIRFOIL_STATE_TABLE`.
+ * Effect's SQL KeyValueStore owns the table, while `KeyValueStore.prefix`
+ * provides application-level isolation between connector instances in that
+ * table. The resulting layer exposes only StateStore, never the unscoped
+ * KeyValueStore.
+ *
+ * @example
+ * ```ts
+ * const StateStoreLive = layerSql().pipe(Layer.provide(PostgresLive));
+ * ```
+ */
+declare const layerSql: () => Layer.Layer<StateStore, Config.ConfigError, SqlClient.SqlClient>;
+declare namespace index_d_exports {
+  export { StateStore, StateStoreService, layerMemory, layerSql };
+}
+//#endregion
+export { StateStoreService as a, StateStore as i, layerSql as n, layerMemory as r, index_d_exports as t };
+//# sourceMappingURL=index-Coh_SkBs.d.ts.map