@useairfoil/producer-linear 0.0.1 → 0.0.2

package/dist/src-Ci3_ltan.mjs

@@ -0,0 +1,1691 @@
+import { t as __exportAll } from "./rolldown-runtime-D7D4PA-g.mjs";
+import { LinearConfigDef, manifest } from "./manifest.mjs";
+import { Connector, ConnectorError, Cursor, Fetch, Iceberg, Metrics, Resource, Telemetry, Webhook } from "@useairfoil/connector-kit";
+import { Array, Config, Context, Data, DateTime, Duration, Effect, Layer, Option, Redacted, Result, Schedule, Schema, SchemaTransformation, Stream, String as String$1, Struct } from "effect";
+import { HttpClient, HttpClientRequest, HttpClientResponse, HttpServerResponse } from "effect/http";
+import { createHmac, timingSafeEqual } from "node:crypto";
+//#region src/client/client.ts
+var client_exports = /* @__PURE__ */ __exportAll({
+	LinearClient: () => LinearClient,
+	layer: () => layer$1,
+	layerConfig: () => layerConfig$1,
+	make: () => make$1
+});
+const endpoint = "https://api.linear.app/graphql";
+const maxRetries = 5;
+const retryBaseDelay = Duration.seconds(1);
+const requestTimeout = Duration.minutes(2);
+const limitRetry = Schedule.min([Schedule.exponential("1 minute"), Schedule.spaced("10 minutes")]);
+var LinearClient = class extends Context.Service()("@useairfoil/producer-linear/LinearClient") {};
+const ResponseSchema = Schema.Struct({
+	data: Schema.optional(Schema.Unknown),
+	errors: Schema.optional(Schema.Array(Schema.Struct({
+		message: Schema.String,
+		extensions: Schema.optional(Schema.Struct({ code: Schema.optional(Schema.String) }))
+	})))
+});
+var RateLimited = class extends Data.TaggedError("RateLimited") {};
+const isNotFound = (message) => message.startsWith("Entity not found");
+const operationName = (document) => /^\s*query\s+(\w+)/.exec(document)?.[1] ?? "query";
+const make$1 = Effect.fnUntraced(function* (config) {
+	const client = (yield* HttpClient.HttpClient).pipe(HttpClient.mapRequest((request) => request.pipe(HttpClientRequest.acceptJson, HttpClientRequest.setHeader("Authorization", Redacted.value(config.apiKey)))), HttpClient.retryTransient({ schedule: Metrics.retrySchedule({
+		connector: manifest.name,
+		baseDelay: retryBaseDelay,
+		times: maxRetries
+	}) }));
+	const execute = (schema, document, variables = {}) => {
+		const operation = operationName(document);
+		return Effect.gen(function* () {
+			const response = yield* client.execute(HttpClientRequest.post(endpoint).pipe(HttpClientRequest.bodyJsonUnsafe({
+				query: document,
+				variables
+			}))).pipe(Effect.tapError((error) => Telemetry.annotateError("api_http", error)), Effect.mapError((error) => new ConnectorError({
+				message: `Linear API request failed for ${operation}`,
+				cause: error
+			})));
+			const body = yield* HttpClientResponse.schemaBodyJson(ResponseSchema)(response).pipe(Effect.tapError((error) => Telemetry.annotateError("api_status", error)), Effect.mapError((error) => new ConnectorError({
+				message: `Linear API returned ${response.status} for ${operation}`,
+				cause: error
+			})));
+			const errors = body.errors ?? [];
+			if (errors.some((error) => error.extensions?.code === "RATELIMITED")) return yield* new RateLimited({ message: `Linear rate limit reached for ${operation}` });
+			if (response.status === 401) return yield* new ConnectorError({ message: "Linear rejected the API key" });
+			if (errors.length > 0 && errors.every((error) => isNotFound(error.message))) return Option.none();
+			const [first] = errors;
+			if (first !== void 0 || response.status < 200 || response.status >= 300) {
+				const error = new ConnectorError({
+					message: `Linear API returned ${response.status} for ${operation}${first ? `: ${first.message}` : ""}`,
+					cause: errors
+				});
+				yield* Telemetry.annotateError("api_graphql", error);
+				return yield* error;
+			}
+			return Option.some(yield* Schema.decodeUnknownEffect(schema)(body.data).pipe(Effect.tapError((error) => Telemetry.annotateError("api_decode", error)), Effect.mapError((error) => new ConnectorError({
+				message: `Linear API response for ${operation} does not match the schema`,
+				cause: error
+			}))));
+		}).pipe(Effect.timeoutOrElse({
+			duration: requestTimeout,
+			orElse: () => Effect.fail(new ConnectorError({ message: `Linear API request timed out for ${operation}` }))
+		}), Effect.retry({
+			schedule: limitRetry.pipe(Schedule.tap(({ duration }) => Effect.logWarning("Linear rate limit reached, waiting to try again").pipe(Effect.annotateLogs({
+				operation,
+				waitMillis: Duration.toMillis(duration)
+			})))),
+			while: (error) => error._tag === "RateLimited"
+		}), Effect.catchTag("RateLimited", (error) => Effect.fail(new ConnectorError({ message: error.message }))), Effect.withSpan(Telemetry.SpanName.apiFetch, {
+			kind: "client",
+			attributes: { [Telemetry.Attr.apiPath]: `graphql:${operation}` }
+		}));
+	};
+	const query = (schema, document, variables) => execute(schema, document, variables).pipe(Effect.flatMap(Option.match({
+		onNone: () => Effect.fail(new ConnectorError({ message: `Linear API found nothing for ${operationName(document)}` })),
+		onSome: Effect.succeed
+	})));
+	return LinearClient.of({
+		query,
+		find: execute
+	});
+});
+const layer$1 = (config) => Layer.effect(LinearClient)(make$1(config));
+const layerConfig$1 = (config) => Layer.unwrap(Config.unwrap(config).pipe(Effect.map(layer$1)));
+//#endregion
+//#region src/schemas/shared.ts
+const field = (fieldId, description) => Iceberg.field(fieldId, { description });
+const Timestamp = Schema.DateFromString;
+/** Decodes a GraphQL Int as bigint for an Iceberg long. */
+const Long = Schema.Int.pipe(Schema.decodeTo(Schema.BigInt, SchemaTransformation.transform({
+	decode: (value) => BigInt(value),
+	encode: (value) => Number(value)
+})));
+/** Decodes a linked object such as `assignee { id }` as its ID. */
+const Ref = Schema.Struct({ id: Schema.String }).pipe(Schema.decodeTo(Schema.String, SchemaTransformation.transform({
+	decode: (ref) => ref.id,
+	encode: (id) => ({ id })
+})));
+const OptionalRef = Schema.NullOr(Ref);
+const OptionalTimestamp = Schema.NullOr(Timestamp);
+const OptionalString = Schema.NullOr(Schema.String);
+const RefConnection = Schema.Struct({ nodes: Schema.Array(Schema.Struct({ id: Schema.String })) });
+/** Decodes connection nodes as IDs. The query must fetch any extra pages. */
+const RefList = (elementId) => RefConnection.pipe(Schema.decodeTo(Schema.Array(Schema.String.annotate({ fieldId: elementId })), SchemaTransformation.transform({
+	decode: (connection) => connection.nodes.map((node) => node.id),
+	encode: (ids) => ({ nodes: ids.map((id) => ({ id })) })
+})));
+const list = (elementId, item) => Schema.Array(item.annotate({ fieldId: elementId }));
+/** Rows use updated_at as version; lifecycle webhooks use the webhook time. */
+const common = (object) => ({
+	id: Schema.String.pipe(field(1, `${object} ID.`)),
+	version: Schema.Date.pipe(field(2, `Time Linear last changed the ${object.toLowerCase()}.`)),
+	created_at: Timestamp.pipe(field(3, `Time the ${object.toLowerCase()} was created.`)),
+	updated_at: Timestamp.pipe(field(4, `Time the ${object.toLowerCase()} was last updated.`)),
+	archived_at: Schema.NullOr(Timestamp).pipe(field(5, `Time the ${object.toLowerCase()} was archived or trashed.`))
+});
+const deleted = (object) => Schema.optional(Schema.Boolean).pipe(field(6, `Whether the ${object} was deleted in Linear.`));
+//#endregion
+//#region src/schemas/comments.ts
+const CommentSchema = Schema.Struct({
+	...common("Comment"),
+	_deleted: deleted("comment"),
+	body: Schema.String.pipe(field(10, "Comment text in markdown.")),
+	user_id: OptionalRef.pipe(field(11, "User who wrote the comment.")),
+	external_user_id: OptionalRef.pipe(field(12, "External user who wrote the comment.")),
+	issue_id: OptionalString.pipe(field(13, "Issue the comment is on.")),
+	project_id: OptionalString.pipe(field(14, "Project the comment is on.")),
+	project_update_id: OptionalString.pipe(field(15, "Project update the comment is on.")),
+	initiative_id: OptionalString.pipe(field(16, "Initiative the comment is on.")),
+	initiative_update_id: OptionalString.pipe(field(17, "Initiative update the comment is on.")),
+	document_content_id: OptionalString.pipe(field(18, "Document content the comment is on.")),
+	parent_id: OptionalString.pipe(field(19, "Comment this one replies to.")),
+	quoted_text: OptionalString.pipe(field(20, "Text the comment quotes.")),
+	edited_at: OptionalTimestamp.pipe(field(21, "Time the comment was last edited.")),
+	resolved_at: OptionalTimestamp.pipe(field(22, "Time the thread was resolved.")),
+	resolving_user_id: OptionalRef.pipe(field(23, "User who resolved the thread.")),
+	url: Schema.String.pipe(field(24, "Comment URL."))
+}).annotate({ description: "Linear comments on issues, projects, initiatives, and updates." }).pipe(Iceberg.identifier("id"));
+const CommentObjectSchema = CommentSchema.mapFields((fields) => Struct.omit(fields, ["version", "_deleted"]));
+//#endregion
+//#region src/resources/pages.ts
+const changesInterval = Duration.minutes(5);
+const hourly = Duration.hours(1);
+const maxPagesPerRun = 20;
+const changesOverlap = Duration.minutes(1);
+/** Keeps item types inferred in the callbacks. */
+const listSpec = (spec) => spec;
+const rowsOf = (toRow) => (items) => Effect.succeed(items.map(toRow));
+const PageInfoSchema = Schema.Struct({
+	hasNextPage: Schema.Boolean,
+	endCursor: Schema.NullOr(Schema.String)
+});
+const readPage = (client, spec, options) => client.query(Schema.Struct({ page: Schema.Struct({
+	nodes: Schema.Array(spec.item),
+	pageInfo: PageInfoSchema
+}) }).pipe(Schema.encodeKeys({ page: spec.connection })), `query ${String$1.capitalize(spec.connection)}($first: Int!, $after: String, $orderBy: PaginationOrderBy) {
+  ${spec.connection}(first: $first, after: $after, orderBy: $orderBy, includeArchived: true) {
+    nodes { ${spec.fields} }
+    pageInfo { hasNextPage endCursor }
+  }
+}`, {
+	first: options.first ?? spec.first ?? 250,
+	after: Option.getOrNull(options.after),
+	orderBy: options.orderBy
+}).pipe(Effect.map(({ page }) => ({
+	items: page.nodes,
+	next: page.pageInfo.hasNextPage ? Option.fromNullishOr(page.pageInfo.endCursor) : Option.none()
+})));
+const listAll = (client, spec) => Stream.paginate(Option.none(), (after) => readPage(client, spec, {
+	orderBy: "createdAt",
+	after
+}).pipe(Effect.map(({ items, next }) => [items, Option.map(next, Option.some)]))).pipe(Stream.runCollect);
+const checkList = (client, spec) => readPage(client, spec, {
+	orderBy: "createdAt",
+	after: Option.none(),
+	first: 1
+}).pipe(Effect.flatMap(({ items }) => spec.rows(items)), Effect.asVoid);
+/** Small lists are read in full every hour. */
+const listSources = (client, spec) => {
+	const read = listAll(client, spec).pipe(Effect.flatMap(spec.rows));
+	return {
+		check: checkList(client, spec),
+		backfill: Fetch.page({
+			pageCursor: Cursor.string(),
+			cutoff: Cursor.isoDateTime(),
+			fetch: () => read.pipe(Effect.map((rows) => ({
+				rows,
+				hasMore: false
+			})))
+		}),
+		changes: Fetch.changes({
+			cursor: Cursor.string(),
+			interval: hourly,
+			fetch: () => Effect.all([read, DateTime.now]).pipe(Effect.map(([rows, now]) => ({
+				rows,
+				cursor: DateTime.formatIso(now)
+			})))
+		})
+	};
+};
+/** Changes pick up items created during backfill. */
+const backfillList = (client, spec) => Fetch.page({
+	pageCursor: Cursor.string(),
+	cutoff: Cursor.isoDateTime(),
+	fetch: ({ pageCursor }) => Effect.gen(function* () {
+		const page = yield* readPage(client, spec, {
+			orderBy: "createdAt",
+			after: Option.fromNullishOr(typeof pageCursor === "string" ? pageCursor : void 0)
+		});
+		return {
+			rows: yield* spec.rows(page.items),
+			hasMore: Option.isSome(page.next),
+			...Option.match(page.next, {
+				onNone: () => ({}),
+				onSome: (nextPageCursor) => ({ nextPageCursor })
+			})
+		};
+	})
+});
+/**
+* `since` is when the last run started. `pending` is set while a run is split:
+* `until` is the start of that run, and `after` the page to go on from.
+*/
+const ChangesCursorSchema = Schema.Struct({
+	since: Schema.DateTimeUtcFromString,
+	pending: Schema.optional(Schema.Struct({
+		until: Schema.DateTimeUtcFromString,
+		after: Schema.String
+	}))
+});
+const ChangesCursorCodec = Schema.Union([Schema.fromJsonString(ChangesCursorSchema), Schema.DateTimeUtcFromString.pipe(Schema.decodeTo(Schema.toType(ChangesCursorSchema), SchemaTransformation.transform({
+	decode: (since) => ({ since }),
+	encode: (cursor) => cursor.since
+})))]);
+const cursorError = (cause) => new ConnectorError({
+	message: "Invalid Linear changes cursor",
+	cause
+});
+/**
+* Newest first: an edit during paging is read again on the next run.
+*/
+const changesList = (client, spec) => Fetch.changes({
+	cursor: Cursor.string(),
+	interval: changesInterval,
+	fetch: ({ cursor }) => Effect.gen(function* () {
+		const state = yield* Schema.decodeUnknownEffect(ChangesCursorCodec)(String(cursor)).pipe(Effect.mapError(cursorError));
+		const until = state.pending?.until ?? (yield* DateTime.now);
+		const from = DateTime.toDateUtc(DateTime.subtractDuration(state.since, changesOverlap));
+		const isRecent = (item) => spec.updatedAt(item).getTime() >= from.getTime();
+		const pages = yield* Stream.paginate(Option.fromNullishOr(state.pending?.after), (after) => Effect.gen(function* () {
+			const page = yield* readPage(client, spec, {
+				orderBy: "updatedAt",
+				after
+			});
+			const recent = page.items.filter(isRecent);
+			const next = recent.length === page.items.length ? page.next : Option.none();
+			return [[{
+				rows: yield* spec.rows(recent),
+				next
+			}], Option.map(next, Option.some)];
+		})).pipe(Stream.take(maxPagesPerRun), Stream.runCollect);
+		const rows = pages.flatMap((page) => page.rows);
+		const after = Option.flatMap(Array.last(pages), (page) => page.next);
+		const next = pages.length === maxPagesPerRun && Option.isSome(after) ? {
+			since: state.since,
+			pending: {
+				until,
+				after: after.value
+			}
+		} : { since: until };
+		return {
+			rows,
+			cursor: yield* Schema.encodeEffect(Schema.fromJsonString(ChangesCursorSchema))(next).pipe(Effect.mapError(cursorError)),
+			hasMore: next.pending !== void 0
+		};
+	})
+});
+const WebhookPayloadSchema = Schema.Struct({
+	data: Schema.Struct({ id: Schema.String }),
+	webhookTimestamp: Schema.Number
+});
+/**
+* Archive and trash also send `remove`, without changing `updatedAt`.
+* Read the item again; delete only if it's gone. Use the webhook time as the version.
+*/
+const webhookList = (client, spec) => ({
+	schema: WebhookPayloadSchema,
+	handler: ({ payload }) => Effect.gen(function* () {
+		const version = new Date(payload.webhookTimestamp);
+		const single = spec.single ?? spec.connection;
+		const found = yield* client.find(Schema.Struct({ item: spec.item }).pipe(Schema.encodeKeys({ item: single })), `query ${String$1.capitalize(single)}($id: String!) {
+  ${single}(id: $id) { ${spec.fields} }
+}`, { id: payload.data.id });
+		return yield* Option.match(found, {
+			onNone: () => Effect.succeed([{
+				id: payload.data.id,
+				version,
+				_deleted: true
+			}]),
+			onSome: ({ item }) => spec.rows([item]).pipe(Effect.map((rows) => rows.map((row) => ({
+				...row,
+				version
+			}))))
+		});
+	})
+});
+//#endregion
+//#region src/resources/comments.ts
+const commentSpec = listSpec({
+	connection: "comments",
+	single: "comment",
+	fields: `id created_at: createdAt updated_at: updatedAt archived_at: archivedAt
+    body user_id: user { id } external_user_id: externalUser { id }
+    issue_id: issueId project_id: projectId project_update_id: projectUpdateId
+    initiative_id: initiativeId initiative_update_id: initiativeUpdateId
+    document_content_id: documentContentId parent_id: parentId quoted_text: quotedText
+    edited_at: editedAt resolved_at: resolvedAt resolving_user_id: resolvingUser { id } url`,
+	item: CommentObjectSchema,
+	updatedAt: (comment) => comment.updated_at,
+	rows: rowsOf((comment) => ({
+		...comment,
+		version: comment.updated_at,
+		_deleted: false
+	}))
+});
+const makeComments = (client) => Resource.entity({
+	name: "comments",
+	rowSchema: CommentSchema,
+	version: "version",
+	check: checkList(client, commentSpec),
+	backfill: backfillList(client, commentSpec),
+	changes: changesList(client, commentSpec),
+	webhook: webhookList(client, commentSpec)
+});
+//#endregion
+//#region src/schemas/customers.ts
+const CustomerSchema = Schema.Struct({
+	...common("Customer"),
+	_deleted: deleted("customer"),
+	name: Schema.String.pipe(field(10, "Customer name.")),
+	domains: list(101, Schema.String).pipe(field(11, "Email domains of the customer.")),
+	external_ids: list(102, Schema.String).pipe(field(12, "IDs in other systems.")),
+	logo_url: OptionalString.pipe(field(13, "Logo URL.")),
+	owner_id: OptionalRef.pipe(field(14, "User who owns the customer.")),
+	status_id: Ref.pipe(field(15, "Customer status.")),
+	tier_id: OptionalRef.pipe(field(16, "Customer tier.")),
+	revenue: Schema.NullOr(Long).pipe(field(17, "Annual revenue.")),
+	size: Schema.NullOr(Schema.Finite).pipe(field(18, "Company size.")),
+	approximate_need_count: Schema.Finite.pipe(field(19, "About how many requests it has.")),
+	url: Schema.String.pipe(field(20, "Customer URL."))
+}).annotate({ description: "Linear customers." }).pipe(Iceberg.identifier("id"));
+const CustomerObjectSchema = CustomerSchema.mapFields((fields) => Struct.omit(fields, ["version", "_deleted"]));
+const CustomerNeedSchema = Schema.Struct({
+	...common("Request"),
+	_deleted: deleted("request"),
+	customer_id: OptionalRef.pipe(field(10, "Customer.")),
+	issue_id: OptionalRef.pipe(field(11, "Issue the request is linked to.")),
+	project_id: OptionalRef.pipe(field(12, "Project the request is linked to.")),
+	original_issue_id: OptionalRef.pipe(field(13, "Issue the request was first linked to.")),
+	comment_id: OptionalRef.pipe(field(14, "Comment the request came from.")),
+	attachment_id: OptionalRef.pipe(field(15, "Attachment the request came from.")),
+	creator_id: OptionalRef.pipe(field(16, "User who added the request.")),
+	body: OptionalString.pipe(field(17, "Request text in markdown.")),
+	priority: Schema.Finite.pipe(field(18, "0 normal, 1 important.")),
+	url: OptionalString.pipe(field(19, "Source URL."))
+}).annotate({ description: "Linear customer requests, linked to issues or projects." }).pipe(Iceberg.identifier("id"));
+const CustomerNeedObjectSchema = CustomerNeedSchema.mapFields((fields) => Struct.omit(fields, ["version", "_deleted"]));
+const levelFields$1 = (object) => ({
+	...common(object),
+	name: Schema.String.pipe(field(10, "Name.")),
+	display_name: Schema.String.pipe(field(11, "Name shown in Linear.")),
+	description: OptionalString.pipe(field(12, "Description.")),
+	color: Schema.String.pipe(field(13, "Color, as hex.")),
+	position: Schema.Finite.pipe(field(14, "Order in the list."))
+});
+const CustomerStatusSchema = Schema.Struct(levelFields$1("Status")).annotate({ description: "Linear customer statuses. Names the IDs in `customers.status_id`." }).pipe(Iceberg.identifier("id"));
+const CustomerStatusObjectSchema = CustomerStatusSchema.mapFields((fields) => Struct.omit(fields, ["version"]));
+const CustomerTierSchema = Schema.Struct(levelFields$1("Tier")).annotate({ description: "Linear customer tiers. Names the IDs in `customers.tier_id`." }).pipe(Iceberg.identifier("id"));
+const CustomerTierObjectSchema = CustomerTierSchema.mapFields((fields) => Struct.omit(fields, ["version"]));
+//#endregion
+//#region src/resources/customers.ts
+const customerSpec = listSpec({
+	connection: "customers",
+	single: "customer",
+	fields: `id created_at: createdAt updated_at: updatedAt archived_at: archivedAt
+    name domains external_ids: externalIds logo_url: logoUrl owner_id: owner { id }
+    status_id: status { id } tier_id: tier { id } revenue size
+    approximate_need_count: approximateNeedCount url`,
+	item: CustomerObjectSchema,
+	updatedAt: (customer) => customer.updated_at,
+	rows: rowsOf((customer) => ({
+		...customer,
+		version: customer.updated_at,
+		_deleted: false
+	}))
+});
+const makeCustomers = (client) => Resource.entity({
+	name: "customers",
+	rowSchema: CustomerSchema,
+	version: "version",
+	check: checkList(client, customerSpec),
+	backfill: backfillList(client, customerSpec),
+	changes: changesList(client, customerSpec),
+	webhook: webhookList(client, customerSpec)
+});
+const customerNeedSpec = listSpec({
+	connection: "customerNeeds",
+	single: "customerNeed",
+	fields: `id created_at: createdAt updated_at: updatedAt archived_at: archivedAt
+    customer_id: customer { id } issue_id: issue { id } project_id: project { id }
+    original_issue_id: originalIssue { id } comment_id: comment { id }
+    attachment_id: attachment { id } creator_id: creator { id } body priority url`,
+	item: CustomerNeedObjectSchema,
+	updatedAt: (need) => need.updated_at,
+	rows: rowsOf((need) => ({
+		...need,
+		version: need.updated_at,
+		_deleted: false
+	}))
+});
+const makeCustomerNeeds = (client) => Resource.entity({
+	name: "customer_needs",
+	rowSchema: CustomerNeedSchema,
+	version: "version",
+	check: checkList(client, customerNeedSpec),
+	backfill: backfillList(client, customerNeedSpec),
+	changes: changesList(client, customerNeedSpec),
+	webhook: webhookList(client, customerNeedSpec)
+});
+const levelFields = `id created_at: createdAt updated_at: updatedAt archived_at: archivedAt name display_name: displayName description color position`;
+const customerStatusSpec = listSpec({
+	connection: "customerStatuses",
+	fields: levelFields,
+	item: CustomerStatusObjectSchema,
+	updatedAt: (status) => status.updated_at,
+	rows: rowsOf((status) => ({
+		...status,
+		version: status.updated_at
+	}))
+});
+const makeCustomerStatuses = (client) => Resource.entity({
+	name: "customer_statuses",
+	rowSchema: CustomerStatusSchema,
+	version: "version",
+	...listSources(client, customerStatusSpec)
+});
+const customerTierSpec = listSpec({
+	connection: "customerTiers",
+	fields: levelFields,
+	item: CustomerTierObjectSchema,
+	updatedAt: (tier) => tier.updated_at,
+	rows: rowsOf((tier) => ({
+		...tier,
+		version: tier.updated_at
+	}))
+});
+const makeCustomerTiers = (client) => Resource.entity({
+	name: "customer_tiers",
+	rowSchema: CustomerTierSchema,
+	version: "version",
+	...listSources(client, customerTierSpec)
+});
+//#endregion
+//#region src/schemas/documents.ts
+const DocumentSchema = Schema.Struct({
+	...common("Document"),
+	_deleted: deleted("document"),
+	title: Schema.String.pipe(field(10, "Title.")),
+	content: OptionalString.pipe(field(11, "Content in markdown.")),
+	url: Schema.String.pipe(field(12, "Document URL.")),
+	icon: OptionalString.pipe(field(13, "Icon.")),
+	color: OptionalString.pipe(field(14, "Icon color.")),
+	creator_id: OptionalRef.pipe(field(15, "User who made the document.")),
+	updated_by_id: OptionalRef.pipe(field(16, "User who last changed the document.")),
+	project_id: OptionalRef.pipe(field(17, "Project the document is in.")),
+	initiative_id: OptionalRef.pipe(field(18, "Initiative the document is in.")),
+	issue_id: OptionalRef.pipe(field(19, "Issue the document is in.")),
+	cycle_id: OptionalRef.pipe(field(20, "Cycle the document is in.")),
+	team_id: OptionalRef.pipe(field(21, "Team the document is in.")),
+	parent_document_id: OptionalRef.pipe(field(22, "Parent document.")),
+	hidden_at: OptionalTimestamp.pipe(field(23, "Time the document was hidden.")),
+	trashed: Schema.NullOr(Schema.Boolean).pipe(field(24, "Whether the document is in the trash."))
+}).annotate({ description: "Linear documents, including archived and trashed ones." }).pipe(Iceberg.identifier("id"));
+//#endregion
+//#region src/resources/documents.ts
+const documentSpec = listSpec({
+	connection: "documents",
+	single: "document",
+	fields: `id created_at: createdAt updated_at: updatedAt archived_at: archivedAt
+    title content url icon color creator_id: creator { id } updated_by_id: updatedBy { id }
+    project_id: project { id } initiative_id: initiative { id } issue_id: issue { id }
+    cycle_id: cycle { id } team_id: team { id } parent_document_id: parentDocument { id }
+    hidden_at: hiddenAt trashed`,
+	item: DocumentSchema.mapFields((fields) => Struct.omit(fields, ["version", "_deleted"])),
+	updatedAt: (document) => document.updated_at,
+	rows: rowsOf((document) => ({
+		...document,
+		version: document.updated_at,
+		_deleted: false
+	}))
+});
+const makeDocuments = (client) => Resource.entity({
+	name: "documents",
+	rowSchema: DocumentSchema,
+	version: "version",
+	check: checkList(client, documentSpec),
+	backfill: backfillList(client, documentSpec),
+	changes: changesList(client, documentSpec),
+	webhook: webhookList(client, documentSpec)
+});
+//#endregion
+//#region src/schemas/initiatives.ts
+const InitiativeSchema = Schema.Struct({
+	...common("Initiative"),
+	_deleted: deleted("initiative"),
+	name: Schema.String.pipe(field(10, "Initiative name.")),
+	description: OptionalString.pipe(field(11, "Short summary.")),
+	content: OptionalString.pipe(field(12, "Initiative overview in markdown.")),
+	url: Schema.String.pipe(field(13, "Initiative URL.")),
+	icon: OptionalString.pipe(field(14, "Icon.")),
+	color: OptionalString.pipe(field(15, "Color, as hex.")),
+	status: Schema.String.pipe(field(16, "Status: Planned, Active, or Completed.")),
+	health: OptionalString.pipe(field(17, "Health from the latest update.")),
+	health_updated_at: OptionalTimestamp.pipe(field(18, "Time the health last changed.")),
+	priority: Long.pipe(field(19, "0 none, 1 urgent, 2 high, 3 medium, 4 low.")),
+	owner_id: OptionalRef.pipe(field(20, "Initiative owner.")),
+	creator_id: OptionalRef.pipe(field(21, "User who made the initiative.")),
+	parent_initiative_id: OptionalRef.pipe(field(22, "Parent initiative.")),
+	target_date: OptionalString.pipe(field(23, "Target date, as YYYY-MM-DD.")),
+	started_at: OptionalTimestamp.pipe(field(24, "Time the initiative started.")),
+	completed_at: OptionalTimestamp.pipe(field(25, "Time the initiative was completed.")),
+	canceled_at: OptionalTimestamp.pipe(field(26, "Time the initiative was canceled.")),
+	label_ids: list(101, Schema.String).pipe(field(27, "Initiative labels.")),
+	visibility: Schema.String.pipe(field(28, "Who can see the initiative.")),
+	trashed: Schema.NullOr(Schema.Boolean).pipe(field(29, "Whether the initiative is in the trash."))
+}).annotate({ description: "Linear initiatives, including archived and trashed ones." }).pipe(Iceberg.identifier("id"));
+const InitiativeObjectSchema = InitiativeSchema.mapFields((fields) => Struct.omit(fields, ["version", "_deleted"]));
+const InitiativeUpdateSchema = Schema.Struct({
+	...common("Update"),
+	_deleted: deleted("update"),
+	initiative_id: Ref.pipe(field(10, "Initiative.")),
+	user_id: Ref.pipe(field(11, "User who posted the update.")),
+	body: Schema.String.pipe(field(12, "Update text in markdown.")),
+	health: Schema.String.pipe(field(13, "Health: onTrack, atRisk, or offTrack.")),
+	url: Schema.String.pipe(field(14, "Update URL.")),
+	edited_at: OptionalTimestamp.pipe(field(15, "Time the update was last edited.")),
+	comment_count: Long.pipe(field(16, "Comments on the update."))
+}).annotate({ description: "Linear initiative updates: status posts with a health." }).pipe(Iceberg.identifier("id"));
+const InitiativeUpdateObjectSchema = InitiativeUpdateSchema.mapFields((fields) => Struct.omit(fields, ["version", "_deleted"]));
+const InitiativeLabelSchema = Schema.Struct({
+	...common("Label"),
+	name: Schema.String.pipe(field(10, "Label name.")),
+	description: OptionalString.pipe(field(11, "Label description.")),
+	color: Schema.String.pipe(field(12, "Label color, as hex.")),
+	is_group: Schema.Boolean.pipe(field(13, "Whether the label groups other labels.")),
+	parent_id: OptionalRef.pipe(field(14, "Label group.")),
+	creator_id: OptionalRef.pipe(field(15, "User who made the label.")),
+	retired_at: OptionalTimestamp.pipe(field(16, "Time the label was retired."))
+}).annotate({ description: "Linear initiative labels. Names the IDs in `initiatives.label_ids`." }).pipe(Iceberg.identifier("id"));
+const InitiativeLabelObjectSchema = InitiativeLabelSchema.mapFields((fields) => Struct.omit(fields, ["version"]));
+const InitiativeRelationSchema = Schema.Struct({
+	...common("Relation"),
+	initiative_id: Ref.pipe(field(10, "Initiative the relation starts from.")),
+	related_initiative_id: Ref.pipe(field(11, "Related initiative.")),
+	sort_order: Schema.Finite.pipe(field(12, "Order.")),
+	user_id: OptionalRef.pipe(field(13, "User who made the relation."))
+}).annotate({ description: "Linear initiative relations. Deleted relations aren't seen." }).pipe(Iceberg.identifier("id"));
+const InitiativeRelationObjectSchema = InitiativeRelationSchema.mapFields((fields) => Struct.omit(fields, ["version"]));
+const InitiativeToProjectSchema = Schema.Struct({
+	...common("Link"),
+	initiative_id: Ref.pipe(field(10, "Initiative.")),
+	project_id: Ref.pipe(field(11, "Project.")),
+	sort_order: Schema.String.pipe(field(12, "Order within the initiative."))
+}).annotate({ description: "Links between Linear initiatives and projects. Removed links aren't seen." }).pipe(Iceberg.identifier("id"));
+const InitiativeToProjectObjectSchema = InitiativeToProjectSchema.mapFields((fields) => Struct.omit(fields, ["version"]));
+//#endregion
+//#region src/resources/initiatives.ts
+const initiativeSpec = listSpec({
+	connection: "initiatives",
+	single: "initiative",
+	fields: `id created_at: createdAt updated_at: updatedAt archived_at: archivedAt
+    name description content url icon color status health
+    health_updated_at: healthUpdatedAt priority owner_id: owner { id } creator_id: creator { id }
+    parent_initiative_id: parentInitiative { id } target_date: targetDate
+    started_at: startedAt completed_at: completedAt canceled_at: canceledAt
+    label_ids: labelIds visibility trashed`,
+	item: InitiativeObjectSchema,
+	updatedAt: (initiative) => initiative.updated_at,
+	rows: rowsOf((initiative) => ({
+		...initiative,
+		version: initiative.updated_at,
+		_deleted: false
+	}))
+});
+const makeInitiatives = (client) => Resource.entity({
+	name: "initiatives",
+	rowSchema: InitiativeSchema,
+	version: "version",
+	check: checkList(client, initiativeSpec),
+	backfill: backfillList(client, initiativeSpec),
+	changes: changesList(client, initiativeSpec),
+	webhook: webhookList(client, initiativeSpec)
+});
+const initiativeUpdateSpec = listSpec({
+	connection: "initiativeUpdates",
+	single: "initiativeUpdate",
+	fields: `id created_at: createdAt updated_at: updatedAt archived_at: archivedAt
+    initiative_id: initiative { id } user_id: user { id } body health url
+    edited_at: editedAt comment_count: commentCount`,
+	item: InitiativeUpdateObjectSchema,
+	updatedAt: (update) => update.updated_at,
+	rows: rowsOf((update) => ({
+		...update,
+		version: update.updated_at,
+		_deleted: false
+	}))
+});
+const makeInitiativeUpdates = (client) => Resource.entity({
+	name: "initiative_updates",
+	rowSchema: InitiativeUpdateSchema,
+	version: "version",
+	check: checkList(client, initiativeUpdateSpec),
+	backfill: backfillList(client, initiativeUpdateSpec),
+	changes: changesList(client, initiativeUpdateSpec),
+	webhook: webhookList(client, initiativeUpdateSpec)
+});
+const initiativeLabelSpec = listSpec({
+	connection: "initiativeLabels",
+	fields: `id created_at: createdAt updated_at: updatedAt archived_at: archivedAt
+    name description color is_group: isGroup parent_id: parent { id }
+    creator_id: creator { id } retired_at: retiredAt`,
+	item: InitiativeLabelObjectSchema,
+	updatedAt: (label) => label.updated_at,
+	rows: rowsOf((label) => ({
+		...label,
+		version: label.updated_at
+	}))
+});
+const makeInitiativeLabels = (client) => Resource.entity({
+	name: "initiative_labels",
+	rowSchema: InitiativeLabelSchema,
+	version: "version",
+	...listSources(client, initiativeLabelSpec)
+});
+const initiativeRelationSpec = listSpec({
+	connection: "initiativeRelations",
+	fields: `id created_at: createdAt updated_at: updatedAt archived_at: archivedAt
+    initiative_id: initiative { id } related_initiative_id: relatedInitiative { id }
+    sort_order: sortOrder user_id: user { id }`,
+	item: InitiativeRelationObjectSchema,
+	updatedAt: (relation) => relation.updated_at,
+	rows: rowsOf((relation) => ({
+		...relation,
+		version: relation.updated_at
+	}))
+});
+const makeInitiativeRelations = (client) => Resource.entity({
+	name: "initiative_relations",
+	rowSchema: InitiativeRelationSchema,
+	version: "version",
+	check: checkList(client, initiativeRelationSpec),
+	backfill: backfillList(client, initiativeRelationSpec),
+	changes: changesList(client, initiativeRelationSpec)
+});
+const initiativeToProjectSpec = listSpec({
+	connection: "initiativeToProjects",
+	fields: `id created_at: createdAt updated_at: updatedAt archived_at: archivedAt initiative_id: initiative { id } project_id: project { id } sort_order: sortOrder`,
+	item: InitiativeToProjectObjectSchema,
+	updatedAt: (link) => link.updated_at,
+	rows: rowsOf((link) => ({
+		...link,
+		version: link.updated_at
+	}))
+});
+const makeInitiativeToProjects = (client) => Resource.entity({
+	name: "initiative_to_projects",
+	rowSchema: InitiativeToProjectSchema,
+	version: "version",
+	check: checkList(client, initiativeToProjectSpec),
+	backfill: backfillList(client, initiativeToProjectSpec),
+	changes: changesList(client, initiativeToProjectSpec)
+});
+//#endregion
+//#region src/schemas/issues.ts
+const IssueSchema = Schema.Struct({
+	...common("Issue"),
+	_deleted: deleted("issue"),
+	identifier: Schema.String.pipe(field(10, "Readable ID, such as ENG-123.")),
+	number: Schema.Finite.pipe(field(11, "Issue number within its team.")),
+	title: Schema.String.pipe(field(12, "Issue title.")),
+	description: OptionalString.pipe(field(13, "Description in markdown.")),
+	url: Schema.String.pipe(field(14, "Issue URL.")),
+	branch_name: Schema.String.pipe(field(15, "Suggested Git branch name.")),
+	priority: Schema.Finite.pipe(field(16, "0 none, 1 urgent, 2 high, 3 medium, 4 low.")),
+	priority_label: Schema.String.pipe(field(17, "Priority name.")),
+	estimate: Schema.NullOr(Schema.Finite).pipe(field(18, "Estimate, on the team's scale.")),
+	due_date: OptionalString.pipe(field(19, "Due date, as YYYY-MM-DD.")),
+	creator_id: OptionalRef.pipe(field(20, "User who created the issue.")),
+	assignee_id: OptionalRef.pipe(field(21, "Assigned user.")),
+	delegate_id: OptionalRef.pipe(field(22, "Agent user working on the issue.")),
+	snoozed_by_id: OptionalRef.pipe(field(23, "User who snoozed the issue.")),
+	state_id: Ref.pipe(field(24, "Workflow state.")),
+	team_id: Ref.pipe(field(25, "Team the issue belongs to.")),
+	project_id: OptionalRef.pipe(field(26, "Project.")),
+	project_milestone_id: OptionalRef.pipe(field(27, "Project milestone.")),
+	cycle_id: OptionalRef.pipe(field(28, "Cycle.")),
+	parent_id: OptionalRef.pipe(field(29, "Parent issue.")),
+	source_comment_id: OptionalRef.pipe(field(30, "Comment the issue was made from.")),
+	external_user_creator_id: OptionalRef.pipe(field(31, "External user who created the issue through an integration.")),
+	label_ids: list(101, Schema.String).pipe(field(32, "Labels.")),
+	previous_identifiers: list(102, Schema.String).pipe(field(33, "Earlier readable IDs, from before the issue moved team.")),
+	started_at: OptionalTimestamp.pipe(field(34, "Time the issue moved to a started state.")),
+	completed_at: OptionalTimestamp.pipe(field(35, "Time the issue was completed.")),
+	canceled_at: OptionalTimestamp.pipe(field(36, "Time the issue was canceled.")),
+	started_triage_at: OptionalTimestamp.pipe(field(37, "Time the issue entered triage.")),
+	triaged_at: OptionalTimestamp.pipe(field(38, "Time the issue left triage.")),
+	auto_closed_at: OptionalTimestamp.pipe(field(39, "Time the issue was closed automatically.")),
+	auto_archived_at: OptionalTimestamp.pipe(field(40, "Time the issue was archived automatically.")),
+	added_to_cycle_at: OptionalTimestamp.pipe(field(41, "Time the issue was added to its cycle.")),
+	added_to_project_at: OptionalTimestamp.pipe(field(42, "Time the issue was added to its project.")),
+	added_to_team_at: OptionalTimestamp.pipe(field(43, "Time the issue was added to its team.")),
+	snoozed_until_at: OptionalTimestamp.pipe(field(44, "Time the issue is snoozed until.")),
+	sla_type: OptionalString.pipe(field(45, "SLA type.")),
+	sla_started_at: OptionalTimestamp.pipe(field(46, "Time the SLA started.")),
+	sla_breaches_at: OptionalTimestamp.pipe(field(47, "Time the SLA breaches.")),
+	customer_ticket_count: Long.pipe(field(48, "Linked support tickets.")),
+	integration_source_type: OptionalString.pipe(field(49, "Integration that created the issue.")),
+	trashed: Schema.NullOr(Schema.Boolean).pipe(field(50, "Whether the issue is in the trash."))
+}).annotate({ description: "Linear issues, including archived and trashed ones." }).pipe(Iceberg.identifier("id"));
+const IssueObjectSchema = IssueSchema.mapFields((fields) => Struct.omit(fields, ["version", "_deleted"]));
+const IssueHistorySchema = Schema.Struct({
+	...common("History entry"),
+	issue_id: Schema.String.pipe(field(10, "Issue that changed.")),
+	actor_id: OptionalString.pipe(field(11, "User who made the change.")),
+	from_state_id: OptionalString.pipe(field(12, "Workflow state before.")),
+	to_state_id: OptionalString.pipe(field(13, "Workflow state after.")),
+	from_assignee_id: OptionalString.pipe(field(14, "Assignee before.")),
+	to_assignee_id: OptionalString.pipe(field(15, "Assignee after.")),
+	from_cycle_id: OptionalString.pipe(field(16, "Cycle before.")),
+	to_cycle_id: OptionalString.pipe(field(17, "Cycle after.")),
+	from_project_id: OptionalString.pipe(field(18, "Project before.")),
+	to_project_id: OptionalString.pipe(field(19, "Project after.")),
+	from_parent_id: OptionalString.pipe(field(20, "Parent issue before.")),
+	to_parent_id: OptionalString.pipe(field(21, "Parent issue after.")),
+	from_team_id: OptionalString.pipe(field(22, "Team before.")),
+	to_team_id: OptionalString.pipe(field(23, "Team after.")),
+	from_priority: Schema.NullOr(Schema.Finite).pipe(field(24, "Priority before.")),
+	to_priority: Schema.NullOr(Schema.Finite).pipe(field(25, "Priority after.")),
+	from_estimate: Schema.NullOr(Schema.Finite).pipe(field(26, "Estimate before.")),
+	to_estimate: Schema.NullOr(Schema.Finite).pipe(field(27, "Estimate after.")),
+	from_due_date: OptionalString.pipe(field(28, "Due date before, as YYYY-MM-DD.")),
+	to_due_date: OptionalString.pipe(field(29, "Due date after, as YYYY-MM-DD.")),
+	from_title: OptionalString.pipe(field(30, "Title before.")),
+	to_title: OptionalString.pipe(field(31, "Title after.")),
+	added_label_ids: Schema.NullOr(list(101, Schema.String)).pipe(field(32, "Labels added.")),
+	removed_label_ids: Schema.NullOr(list(102, Schema.String)).pipe(field(33, "Labels removed.")),
+	attachment_id: OptionalString.pipe(field(34, "Attachment linked or unlinked.")),
+	customer_need_id: OptionalString.pipe(field(35, "Customer request linked or unlinked.")),
+	to_converted_project_id: OptionalString.pipe(field(36, "Project the issue became.")),
+	updated_description: Schema.NullOr(Schema.Boolean).pipe(field(37, "Whether the description changed.")),
+	archived: Schema.NullOr(Schema.Boolean).pipe(field(38, "Whether the issue was archived.")),
+	trashed: Schema.NullOr(Schema.Boolean).pipe(field(39, "Whether the issue was trashed.")),
+	auto_archived: Schema.NullOr(Schema.Boolean).pipe(field(40, "Whether the issue was archived automatically.")),
+	auto_closed: Schema.NullOr(Schema.Boolean).pipe(field(41, "Whether the issue was closed automatically."))
+}).annotate({ description: "Linear issue history. One row per change to an issue." }).pipe(Iceberg.identifier("id"));
+const IssueHistoryObjectSchema = IssueHistorySchema.mapFields((fields) => Struct.omit(fields, ["version", "issue_id"]));
+const IssueRelationSchema = Schema.Struct({
+	...common("Relation"),
+	issue_id: Ref.pipe(field(10, "Issue the relation starts from.")),
+	related_issue_id: Ref.pipe(field(11, "Related issue.")),
+	type: Schema.String.pipe(field(12, "Relation type: blocks, duplicate, related, or similar."))
+}).annotate({ description: "Linear issue relations. Deleted relations aren't seen." }).pipe(Iceberg.identifier("id"));
+const IssueRelationObjectSchema = IssueRelationSchema.mapFields((fields) => Struct.omit(fields, ["version"]));
+const AttachmentSchema = Schema.Struct({
+	...common("Attachment"),
+	_deleted: deleted("attachment"),
+	issue_id: Ref.pipe(field(10, "Issue the attachment is on.")),
+	creator_id: OptionalRef.pipe(field(11, "User who added it.")),
+	external_user_creator_id: OptionalRef.pipe(field(12, "External user who added it.")),
+	title: Schema.String.pipe(field(13, "Title.")),
+	subtitle: OptionalString.pipe(field(14, "Subtitle.")),
+	url: Schema.String.pipe(field(15, "Linked URL, such as a pull request or ticket.")),
+	source_type: OptionalString.pipe(field(16, "Source, such as github or zendesk."))
+}).annotate({ description: "Linear issue attachments: links to pull requests, tickets, and more." }).pipe(Iceberg.identifier("id"));
+const AttachmentObjectSchema = AttachmentSchema.mapFields((fields) => Struct.omit(fields, ["version", "_deleted"]));
+const IssueLabelSchema = Schema.Struct({
+	...common("Label"),
+	_deleted: deleted("label"),
+	name: Schema.String.pipe(field(10, "Label name.")),
+	description: OptionalString.pipe(field(11, "Label description.")),
+	color: Schema.String.pipe(field(12, "Label color, as hex.")),
+	is_group: Schema.Boolean.pipe(field(13, "Whether the label groups other labels.")),
+	parent_id: OptionalRef.pipe(field(14, "Label group.")),
+	team_id: OptionalRef.pipe(field(15, "Team, or null for a workspace label.")),
+	creator_id: OptionalRef.pipe(field(16, "User who made the label.")),
+	retired_at: OptionalTimestamp.pipe(field(17, "Time the label was retired."))
+}).annotate({ description: "Linear issue labels. Names the IDs in `issues.label_ids`." }).pipe(Iceberg.identifier("id"));
+const IssueLabelObjectSchema = IssueLabelSchema.mapFields((fields) => Struct.omit(fields, ["version", "_deleted"]));
+//#endregion
+//#region src/resources/issue-history.ts
+const historyFields = `
+  id created_at: createdAt updated_at: updatedAt archived_at: archivedAt actor_id: actorId
+  from_state_id: fromStateId to_state_id: toStateId
+  from_assignee_id: fromAssigneeId to_assignee_id: toAssigneeId
+  from_cycle_id: fromCycleId to_cycle_id: toCycleId
+  from_project_id: fromProjectId to_project_id: toProjectId
+  from_parent_id: fromParentId to_parent_id: toParentId from_team_id: fromTeamId to_team_id: toTeamId
+  from_priority: fromPriority to_priority: toPriority
+  from_estimate: fromEstimate to_estimate: toEstimate
+  from_due_date: fromDueDate to_due_date: toDueDate from_title: fromTitle to_title: toTitle
+  added_label_ids: addedLabelIds removed_label_ids: removedLabelIds
+  attachment_id: attachmentId customer_need_id: customerNeedId
+  to_converted_project_id: toConvertedProjectId updated_description: updatedDescription
+  archived trashed auto_archived: autoArchived auto_closed: autoClosed`;
+const HistoryPageSchema = Schema.Struct({
+	nodes: Schema.Array(IssueHistoryObjectSchema),
+	pageInfo: Schema.Struct({
+		hasNextPage: Schema.Boolean,
+		endCursor: Schema.NullOr(Schema.String)
+	})
+});
+const IssueWithHistorySchema = Schema.Struct({
+	id: Schema.String,
+	updated_at: Timestamp,
+	history: HistoryPageSchema
+});
+const nextCursor = ({ pageInfo }) => pageInfo.hasNextPage ? Option.fromNullishOr(pageInfo.endCursor) : Option.none();
+/** Returns the history after the first page, without repeating that page. */
+const readMore = (client, issueId, first) => Option.match(nextCursor(first), {
+	onNone: () => Effect.succeed([]),
+	onSome: (cursor) => Stream.paginate(cursor, (after) => client.query(Schema.Struct({ issue: Schema.Struct({ history: HistoryPageSchema }) }), `query IssueHistory($id: String!, $after: String) {
+  issue(id: $id) { history(first: 250, after: $after) { nodes { ${historyFields} } pageInfo { hasNextPage endCursor } } }
+}`, {
+		id: issueId,
+		after
+	}).pipe(Effect.map(({ issue }) => [issue.history.nodes, nextCursor(issue.history)]))).pipe(Stream.runCollect)
+});
+/** Linear has no top-level history query. */
+const historySpec = (client) => listSpec({
+	connection: "issues",
+	fields: `id updated_at: updatedAt history(first: 50) { nodes { ${historyFields} } pageInfo { hasNextPage endCursor } }`,
+	item: IssueWithHistorySchema,
+	first: 25,
+	updatedAt: (issue) => issue.updated_at,
+	rows: (issues) => Effect.forEach(issues, (issue) => readMore(client, issue.id, issue.history).pipe(Effect.map((more) => [...issue.history.nodes, ...more].map((entry) => ({
+		...entry,
+		issue_id: issue.id,
+		version: entry.updated_at
+	}))))).pipe(Effect.map((rows) => rows.flat()))
+});
+const makeIssueHistory = (client) => {
+	const spec = historySpec(client);
+	return Resource.entity({
+		name: "issue_history",
+		rowSchema: IssueHistorySchema,
+		version: "version",
+		check: checkList(client, spec),
+		backfill: backfillList(client, spec),
+		changes: changesList(client, spec),
+		webhook: {
+			schema: Schema.Struct({ data: Schema.Struct({ id: Schema.String }) }),
+			handler: ({ payload }) => client.find(Schema.Struct({ issue: IssueWithHistorySchema }), `query IssueHistory($id: String!) {
+  issue(id: $id) { ${spec.fields} }
+}`, { id: payload.data.id }).pipe(Effect.flatMap(Option.match({
+				onNone: () => Effect.succeed([]),
+				onSome: ({ issue }) => spec.rows([issue])
+			})))
+		}
+	});
+};
+//#endregion
+//#region src/resources/issues.ts
+const issueSpec = listSpec({
+	connection: "issues",
+	single: "issue",
+	fields: `
+  id created_at: createdAt updated_at: updatedAt archived_at: archivedAt
+  identifier number title description url branch_name: branchName
+  priority priority_label: priorityLabel estimate due_date: dueDate
+  creator_id: creator { id } assignee_id: assignee { id } delegate_id: delegate { id }
+  snoozed_by_id: snoozedBy { id } state_id: state { id } team_id: team { id }
+  project_id: project { id } project_milestone_id: projectMilestone { id }
+  cycle_id: cycle { id } parent_id: parent { id } source_comment_id: sourceComment { id }
+  external_user_creator_id: externalUserCreator { id }
+  label_ids: labelIds previous_identifiers: previousIdentifiers
+  started_at: startedAt completed_at: completedAt canceled_at: canceledAt
+  started_triage_at: startedTriageAt triaged_at: triagedAt auto_closed_at: autoClosedAt
+  auto_archived_at: autoArchivedAt added_to_cycle_at: addedToCycleAt
+  added_to_project_at: addedToProjectAt added_to_team_at: addedToTeamAt
+  snoozed_until_at: snoozedUntilAt sla_type: slaType sla_started_at: slaStartedAt
+  sla_breaches_at: slaBreachesAt customer_ticket_count: customerTicketCount
+  integration_source_type: integrationSourceType trashed`,
+	item: IssueObjectSchema,
+	updatedAt: (issue) => issue.updated_at,
+	rows: rowsOf((issue) => ({
+		...issue,
+		version: issue.updated_at,
+		_deleted: false
+	}))
+});
+const makeIssues = (client) => Resource.entity({
+	name: "issues",
+	rowSchema: IssueSchema,
+	version: "version",
+	check: checkList(client, issueSpec),
+	backfill: backfillList(client, issueSpec),
+	changes: changesList(client, issueSpec),
+	webhook: webhookList(client, issueSpec)
+});
+const issueRelationSpec = listSpec({
+	connection: "issueRelations",
+	fields: `id created_at: createdAt updated_at: updatedAt archived_at: archivedAt
+    issue_id: issue { id } related_issue_id: relatedIssue { id } type`,
+	item: IssueRelationObjectSchema,
+	updatedAt: (relation) => relation.updated_at,
+	rows: rowsOf((relation) => ({
+		...relation,
+		version: relation.updated_at
+	}))
+});
+const makeIssueRelations = (client) => Resource.entity({
+	name: "issue_relations",
+	rowSchema: IssueRelationSchema,
+	version: "version",
+	check: checkList(client, issueRelationSpec),
+	backfill: backfillList(client, issueRelationSpec),
+	changes: changesList(client, issueRelationSpec)
+});
+const attachmentSpec = listSpec({
+	connection: "attachments",
+	single: "attachment",
+	fields: `id created_at: createdAt updated_at: updatedAt archived_at: archivedAt
+    issue_id: issue { id } creator_id: creator { id }
+    external_user_creator_id: externalUserCreator { id }
+    title subtitle url source_type: sourceType`,
+	item: AttachmentObjectSchema,
+	updatedAt: (attachment) => attachment.updated_at,
+	rows: rowsOf((attachment) => ({
+		...attachment,
+		version: attachment.updated_at,
+		_deleted: false
+	}))
+});
+const makeAttachments = (client) => Resource.entity({
+	name: "attachments",
+	rowSchema: AttachmentSchema,
+	version: "version",
+	check: checkList(client, attachmentSpec),
+	backfill: backfillList(client, attachmentSpec),
+	changes: changesList(client, attachmentSpec),
+	webhook: webhookList(client, attachmentSpec)
+});
+const issueLabelSpec = listSpec({
+	connection: "issueLabels",
+	single: "issueLabel",
+	fields: `id created_at: createdAt updated_at: updatedAt archived_at: archivedAt
+    name description color is_group: isGroup parent_id: parent { id } team_id: team { id }
+    creator_id: creator { id } retired_at: retiredAt`,
+	item: IssueLabelObjectSchema,
+	updatedAt: (label) => label.updated_at,
+	rows: rowsOf((label) => ({
+		...label,
+		version: label.updated_at,
+		_deleted: false
+	}))
+});
+const makeIssueLabels = (client) => Resource.entity({
+	name: "issue_labels",
+	rowSchema: IssueLabelSchema,
+	version: "version",
+	...listSources(client, issueLabelSpec),
+	webhook: webhookList(client, issueLabelSpec)
+});
+//#endregion
+//#region src/schemas/projects.ts
+const ProjectSchema = Schema.Struct({
+	...common("Project"),
+	_deleted: deleted("project"),
+	name: Schema.String.pipe(field(10, "Project name.")),
+	description: Schema.String.pipe(field(11, "Short summary.")),
+	content: OptionalString.pipe(field(12, "Project overview in markdown.")),
+	url: Schema.String.pipe(field(13, "Project URL.")),
+	icon: OptionalString.pipe(field(14, "Icon.")),
+	color: Schema.String.pipe(field(15, "Color, as hex.")),
+	status_id: Ref.pipe(field(16, "Project status.")),
+	priority: Long.pipe(field(17, "0 none, 1 urgent, 2 high, 3 medium, 4 low.")),
+	priority_label: Schema.String.pipe(field(18, "Priority name.")),
+	health: OptionalString.pipe(field(19, "Health from the latest update.")),
+	health_updated_at: OptionalTimestamp.pipe(field(20, "Time the health last changed.")),
+	progress: Schema.Finite.pipe(field(21, "Share of the scope completed, from 0 to 1.")),
+	scope: Schema.Finite.pipe(field(22, "Total estimate of the project's issues.")),
+	lead_id: OptionalRef.pipe(field(23, "Project lead.")),
+	creator_id: OptionalRef.pipe(field(24, "User who made the project.")),
+	converted_from_issue_id: OptionalRef.pipe(field(25, "Issue the project was made from.")),
+	start_date: OptionalString.pipe(field(26, "Start date, as YYYY-MM-DD.")),
+	target_date: OptionalString.pipe(field(27, "Target date, as YYYY-MM-DD.")),
+	started_at: OptionalTimestamp.pipe(field(28, "Time the project started.")),
+	completed_at: OptionalTimestamp.pipe(field(29, "Time the project was completed.")),
+	canceled_at: OptionalTimestamp.pipe(field(30, "Time the project was canceled.")),
+	auto_archived_at: OptionalTimestamp.pipe(field(31, "Time the project was archived automatically.")),
+	label_ids: list(101, Schema.String).pipe(field(32, "Project labels.")),
+	team_ids: RefList(102).pipe(field(33, "Teams the project belongs to. Reads up to 50.")),
+	member_ids: RefList(103).pipe(field(34, "Project members. Reads up to 100.")),
+	trashed: Schema.NullOr(Schema.Boolean).pipe(field(35, "Whether the project is in the trash."))
+}).annotate({ description: "Linear projects, including archived and trashed ones." }).pipe(Iceberg.identifier("id"));
+const ProjectObjectSchema = ProjectSchema.mapFields((fields) => Struct.omit(fields, ["version", "_deleted"]));
+const ProjectMilestoneSchema = Schema.Struct({
+	...common("Milestone"),
+	name: Schema.String.pipe(field(10, "Milestone name.")),
+	description: OptionalString.pipe(field(11, "Description in markdown.")),
+	project_id: Ref.pipe(field(12, "Project.")),
+	target_date: OptionalString.pipe(field(13, "Target date, as YYYY-MM-DD.")),
+	status: Schema.String.pipe(field(14, "Status: unstarted, next, overdue, or done.")),
+	progress: Schema.Finite.pipe(field(15, "Share of the scope completed, from 0 to 1.")),
+	sort_order: Schema.Finite.pipe(field(16, "Order within the project."))
+}).annotate({ description: "Linear project milestones. Deleted milestones aren't seen." }).pipe(Iceberg.identifier("id"));
+const ProjectMilestoneObjectSchema = ProjectMilestoneSchema.mapFields((fields) => Struct.omit(fields, ["version"]));
+const ProjectUpdateSchema = Schema.Struct({
+	...common("Update"),
+	_deleted: deleted("update"),
+	project_id: Ref.pipe(field(10, "Project.")),
+	user_id: Ref.pipe(field(11, "User who posted the update.")),
+	body: Schema.String.pipe(field(12, "Update text in markdown.")),
+	health: Schema.String.pipe(field(13, "Health: onTrack, atRisk, or offTrack.")),
+	url: Schema.String.pipe(field(14, "Update URL.")),
+	edited_at: OptionalTimestamp.pipe(field(15, "Time the update was last edited.")),
+	comment_count: Long.pipe(field(16, "Comments on the update."))
+}).annotate({ description: "Linear project updates: status posts with a health." }).pipe(Iceberg.identifier("id"));
+const ProjectUpdateObjectSchema = ProjectUpdateSchema.mapFields((fields) => Struct.omit(fields, ["version", "_deleted"]));
+const ProjectStatusSchema = Schema.Struct({
+	...common("Status"),
+	name: Schema.String.pipe(field(10, "Status name.")),
+	type: Schema.String.pipe(field(11, "Status type: backlog, planned, started, paused, completed, or canceled.")),
+	color: Schema.String.pipe(field(12, "Color, as hex.")),
+	description: OptionalString.pipe(field(13, "Description.")),
+	position: Schema.Finite.pipe(field(14, "Order in the list."))
+}).annotate({ description: "Linear project statuses. Names the IDs in `projects.status_id`." }).pipe(Iceberg.identifier("id"));
+const ProjectStatusObjectSchema = ProjectStatusSchema.mapFields((fields) => Struct.omit(fields, ["version"]));
+const ProjectLabelSchema = Schema.Struct({
+	...common("Label"),
+	_deleted: deleted("label"),
+	name: Schema.String.pipe(field(10, "Label name.")),
+	description: OptionalString.pipe(field(11, "Label description.")),
+	color: Schema.String.pipe(field(12, "Label color, as hex.")),
+	is_group: Schema.Boolean.pipe(field(13, "Whether the label groups other labels.")),
+	parent_id: OptionalRef.pipe(field(14, "Label group.")),
+	creator_id: OptionalRef.pipe(field(15, "User who made the label.")),
+	retired_at: OptionalTimestamp.pipe(field(16, "Time the label was retired."))
+}).annotate({ description: "Linear project labels. Names the IDs in `projects.label_ids`." }).pipe(Iceberg.identifier("id"));
+const ProjectLabelObjectSchema = ProjectLabelSchema.mapFields((fields) => Struct.omit(fields, ["version", "_deleted"]));
+const ProjectRelationSchema = Schema.Struct({
+	...common("Relation"),
+	type: Schema.String.pipe(field(10, "Relation type, such as dependency.")),
+	project_id: Ref.pipe(field(11, "Project the relation starts from.")),
+	project_milestone_id: OptionalRef.pipe(field(12, "Milestone the relation starts from.")),
+	anchor_type: Schema.String.pipe(field(13, "Which end of the project it starts from.")),
+	related_project_id: Ref.pipe(field(14, "Related project.")),
+	related_project_milestone_id: OptionalRef.pipe(field(15, "Related milestone.")),
+	related_anchor_type: Schema.String.pipe(field(16, "Which end of the related project.")),
+	user_id: OptionalRef.pipe(field(17, "User who made the relation."))
+}).annotate({ description: "Linear project dependencies. Deleted relations aren't seen." }).pipe(Iceberg.identifier("id"));
+const ProjectRelationObjectSchema = ProjectRelationSchema.mapFields((fields) => Struct.omit(fields, ["version"]));
+//#endregion
+//#region src/resources/projects.ts
+const projectSpec = listSpec({
+	connection: "projects",
+	single: "project",
+	fields: `id created_at: createdAt updated_at: updatedAt archived_at: archivedAt
+    name description content url icon color status_id: status { id } priority
+    priority_label: priorityLabel health health_updated_at: healthUpdatedAt progress scope
+    lead_id: lead { id } creator_id: creator { id }
+    converted_from_issue_id: convertedFromIssue { id } start_date: startDate
+    target_date: targetDate started_at: startedAt completed_at: completedAt
+    canceled_at: canceledAt auto_archived_at: autoArchivedAt label_ids: labelIds
+    team_ids: teams(first: 50) { nodes { id } } member_ids: members(first: 100) { nodes { id } }
+    trashed`,
+	item: ProjectObjectSchema,
+	first: 50,
+	updatedAt: (project) => project.updated_at,
+	rows: rowsOf((project) => ({
+		...project,
+		version: project.updated_at,
+		_deleted: false
+	}))
+});
+const makeProjects = (client) => Resource.entity({
+	name: "projects",
+	rowSchema: ProjectSchema,
+	version: "version",
+	check: checkList(client, projectSpec),
+	backfill: backfillList(client, projectSpec),
+	changes: changesList(client, projectSpec),
+	webhook: webhookList(client, projectSpec)
+});
+const projectMilestoneSpec = listSpec({
+	connection: "projectMilestones",
+	fields: `id created_at: createdAt updated_at: updatedAt archived_at: archivedAt
+    name description project_id: project { id } target_date: targetDate status progress
+    sort_order: sortOrder`,
+	item: ProjectMilestoneObjectSchema,
+	updatedAt: (milestone) => milestone.updated_at,
+	rows: rowsOf((milestone) => ({
+		...milestone,
+		version: milestone.updated_at
+	}))
+});
+const makeProjectMilestones = (client) => Resource.entity({
+	name: "project_milestones",
+	rowSchema: ProjectMilestoneSchema,
+	version: "version",
+	check: checkList(client, projectMilestoneSpec),
+	backfill: backfillList(client, projectMilestoneSpec),
+	changes: changesList(client, projectMilestoneSpec)
+});
+const projectUpdateSpec = listSpec({
+	connection: "projectUpdates",
+	single: "projectUpdate",
+	fields: `id created_at: createdAt updated_at: updatedAt archived_at: archivedAt
+    project_id: project { id } user_id: user { id } body health url edited_at: editedAt
+    comment_count: commentCount`,
+	item: ProjectUpdateObjectSchema,
+	updatedAt: (update) => update.updated_at,
+	rows: rowsOf((update) => ({
+		...update,
+		version: update.updated_at,
+		_deleted: false
+	}))
+});
+const makeProjectUpdates = (client) => Resource.entity({
+	name: "project_updates",
+	rowSchema: ProjectUpdateSchema,
+	version: "version",
+	check: checkList(client, projectUpdateSpec),
+	backfill: backfillList(client, projectUpdateSpec),
+	changes: changesList(client, projectUpdateSpec),
+	webhook: webhookList(client, projectUpdateSpec)
+});
+const projectStatusSpec = listSpec({
+	connection: "projectStatuses",
+	fields: `id created_at: createdAt updated_at: updatedAt archived_at: archivedAt name type color description position`,
+	item: ProjectStatusObjectSchema,
+	updatedAt: (status) => status.updated_at,
+	rows: rowsOf((status) => ({
+		...status,
+		version: status.updated_at
+	}))
+});
+const makeProjectStatuses = (client) => Resource.entity({
+	name: "project_statuses",
+	rowSchema: ProjectStatusSchema,
+	version: "version",
+	...listSources(client, projectStatusSpec)
+});
+const projectLabelSpec = listSpec({
+	connection: "projectLabels",
+	single: "projectLabel",
+	fields: `id created_at: createdAt updated_at: updatedAt archived_at: archivedAt
+    name description color is_group: isGroup parent_id: parent { id }
+    creator_id: creator { id } retired_at: retiredAt`,
+	item: ProjectLabelObjectSchema,
+	updatedAt: (label) => label.updated_at,
+	rows: rowsOf((label) => ({
+		...label,
+		version: label.updated_at,
+		_deleted: false
+	}))
+});
+const makeProjectLabels = (client) => Resource.entity({
+	name: "project_labels",
+	rowSchema: ProjectLabelSchema,
+	version: "version",
+	...listSources(client, projectLabelSpec),
+	webhook: webhookList(client, projectLabelSpec)
+});
+const projectRelationSpec = listSpec({
+	connection: "projectRelations",
+	fields: `id created_at: createdAt updated_at: updatedAt archived_at: archivedAt
+    type project_id: project { id } project_milestone_id: projectMilestone { id }
+    anchor_type: anchorType related_project_id: relatedProject { id }
+    related_project_milestone_id: relatedProjectMilestone { id }
+    related_anchor_type: relatedAnchorType user_id: user { id }`,
+	item: ProjectRelationObjectSchema,
+	updatedAt: (relation) => relation.updated_at,
+	rows: rowsOf((relation) => ({
+		...relation,
+		version: relation.updated_at
+	}))
+});
+const makeProjectRelations = (client) => Resource.entity({
+	name: "project_relations",
+	rowSchema: ProjectRelationSchema,
+	version: "version",
+	check: checkList(client, projectRelationSpec),
+	backfill: backfillList(client, projectRelationSpec),
+	changes: changesList(client, projectRelationSpec)
+});
+//#endregion
+//#region src/schemas/releases.ts
+const ReleaseSchema = Schema.Struct({
+	...common("Release"),
+	name: Schema.String.pipe(field(10, "Release name.")),
+	description: OptionalString.pipe(field(11, "Description.")),
+	release_version: OptionalString.pipe(field(12, "Version, such as 1.2.0.")),
+	url: Schema.String.pipe(field(13, "Release URL.")),
+	commit_sha: OptionalString.pipe(field(14, "Commit SHA.")),
+	pipeline_id: Ref.pipe(field(15, "Release pipeline.")),
+	stage_id: Ref.pipe(field(16, "Release stage.")),
+	creator_id: OptionalRef.pipe(field(17, "User who made the release.")),
+	start_date: OptionalString.pipe(field(18, "Start date, as YYYY-MM-DD.")),
+	target_date: OptionalString.pipe(field(19, "Target date, as YYYY-MM-DD.")),
+	started_at: OptionalTimestamp.pipe(field(20, "Time the release started.")),
+	completed_at: OptionalTimestamp.pipe(field(21, "Time the release was completed.")),
+	canceled_at: OptionalTimestamp.pipe(field(22, "Time the release was canceled.")),
+	trashed: Schema.NullOr(Schema.Boolean).pipe(field(23, "Whether the release is in the trash."))
+}).annotate({ description: "Linear releases. Needs the Business plan." }).pipe(Iceberg.identifier("id"));
+const ReleaseObjectSchema = ReleaseSchema.mapFields((fields) => Struct.omit(fields, ["version"]));
+const ReleaseNoteSchema = Schema.Struct({
+	...common("Release note"),
+	title: OptionalString.pipe(field(10, "Release note title.")),
+	content: Schema.NullOr(Schema.Struct({ content: OptionalString })).pipe(Schema.decodeTo(OptionalString, SchemaTransformation.transform({
+		decode: (document) => document?.content ?? null,
+		encode: (content) => content === null ? null : { content }
+	})), field(11, "Release note body in markdown.")),
+	url: Schema.String.pipe(field(12, "Release note URL.")),
+	pipeline_id: Ref.pipe(field(13, "Release pipeline.")),
+	release_ids: list(101, Ref).pipe(field(14, "Releases covered by the note."))
+}).annotate({ description: "Linear release notes. Needs the Business plan." }).pipe(Iceberg.identifier("id"));
+const ReleaseNoteObjectSchema = ReleaseNoteSchema.mapFields((fields) => Struct.omit(fields, ["version"]));
+const ReleasePipelineSchema = Schema.Struct({
+	...common("Pipeline"),
+	name: Schema.String.pipe(field(10, "Pipeline name.")),
+	type: Schema.String.pipe(field(11, "Pipeline type.")),
+	is_production: Schema.Boolean.pipe(field(12, "Whether it releases to production.")),
+	url: Schema.String.pipe(field(13, "Pipeline URL.")),
+	include_path_patterns: list(101, Schema.String).pipe(field(14, "File paths that count toward the pipeline.")),
+	approximate_release_count: Long.pipe(field(15, "About how many releases it has.")),
+	trashed: Schema.NullOr(Schema.Boolean).pipe(field(16, "Whether the pipeline is in the trash."))
+}).annotate({ description: "Linear release pipelines. Needs the Business plan." }).pipe(Iceberg.identifier("id"));
+const ReleasePipelineObjectSchema = ReleasePipelineSchema.mapFields((fields) => Struct.omit(fields, ["version"]));
+const ReleaseStageSchema = Schema.Struct({
+	...common("Stage"),
+	name: Schema.String.pipe(field(10, "Stage name.")),
+	type: Schema.String.pipe(field(11, "Stage type.")),
+	color: Schema.String.pipe(field(12, "Color, as hex.")),
+	position: Schema.Finite.pipe(field(13, "Order in the pipeline.")),
+	frozen: Schema.Boolean.pipe(field(14, "Whether the stage is frozen.")),
+	pipeline_id: Ref.pipe(field(15, "Release pipeline."))
+}).annotate({ description: "Linear release stages. Needs the Business plan." }).pipe(Iceberg.identifier("id"));
+const ReleaseStageObjectSchema = ReleaseStageSchema.mapFields((fields) => Struct.omit(fields, ["version"]));
+const IssueToReleaseSchema = Schema.Struct({
+	...common("Link"),
+	issue_id: Ref.pipe(field(10, "Issue.")),
+	release_id: Ref.pipe(field(11, "Release."))
+}).annotate({ description: "Links between Linear issues and releases. Needs the Business plan." }).pipe(Iceberg.identifier("id"));
+const IssueToReleaseObjectSchema = IssueToReleaseSchema.mapFields((fields) => Struct.omit(fields, ["version"]));
+//#endregion
+//#region src/resources/releases.ts
+const releaseSpec = listSpec({
+	connection: "releases",
+	fields: `id created_at: createdAt updated_at: updatedAt archived_at: archivedAt
+    name description release_version: version url commit_sha: commitSha
+    pipeline_id: pipeline { id } stage_id: stage { id } creator_id: creator { id }
+    start_date: startDate target_date: targetDate started_at: startedAt
+    completed_at: completedAt canceled_at: canceledAt trashed`,
+	item: ReleaseObjectSchema,
+	updatedAt: (release) => release.updated_at,
+	rows: rowsOf((release) => ({
+		...release,
+		version: release.updated_at
+	}))
+});
+const makeReleases = (client) => Resource.entity({
+	name: "releases",
+	rowSchema: ReleaseSchema,
+	version: "version",
+	check: checkList(client, releaseSpec),
+	backfill: backfillList(client, releaseSpec),
+	changes: changesList(client, releaseSpec)
+});
+const releaseNoteSpec = listSpec({
+	connection: "releaseNotes",
+	fields: `id created_at: createdAt updated_at: updatedAt archived_at: archivedAt
+    title content: documentContent { content } url pipeline_id: pipeline { id }
+    release_ids: releases { id }`,
+	item: ReleaseNoteObjectSchema,
+	updatedAt: (note) => note.updated_at,
+	rows: rowsOf((note) => ({
+		...note,
+		version: note.updated_at
+	}))
+});
+const makeReleaseNotes = (client) => Resource.entity({
+	name: "release_notes",
+	rowSchema: ReleaseNoteSchema,
+	version: "version",
+	check: checkList(client, releaseNoteSpec),
+	backfill: backfillList(client, releaseNoteSpec),
+	changes: changesList(client, releaseNoteSpec)
+});
+const releasePipelineSpec = listSpec({
+	connection: "releasePipelines",
+	fields: `id created_at: createdAt updated_at: updatedAt archived_at: archivedAt
+    name type is_production: isProduction url include_path_patterns: includePathPatterns
+    approximate_release_count: approximateReleaseCount trashed`,
+	item: ReleasePipelineObjectSchema,
+	updatedAt: (pipeline) => pipeline.updated_at,
+	rows: rowsOf((pipeline) => ({
+		...pipeline,
+		version: pipeline.updated_at
+	}))
+});
+const makeReleasePipelines = (client) => Resource.entity({
+	name: "release_pipelines",
+	rowSchema: ReleasePipelineSchema,
+	version: "version",
+	...listSources(client, releasePipelineSpec)
+});
+const releaseStageSpec = listSpec({
+	connection: "releaseStages",
+	fields: `id created_at: createdAt updated_at: updatedAt archived_at: archivedAt name type color position frozen pipeline_id: pipeline { id }`,
+	item: ReleaseStageObjectSchema,
+	updatedAt: (stage) => stage.updated_at,
+	rows: rowsOf((stage) => ({
+		...stage,
+		version: stage.updated_at
+	}))
+});
+const makeReleaseStages = (client) => Resource.entity({
+	name: "release_stages",
+	rowSchema: ReleaseStageSchema,
+	version: "version",
+	...listSources(client, releaseStageSpec)
+});
+const issueToReleaseSpec = listSpec({
+	connection: "issueToReleases",
+	fields: `id created_at: createdAt updated_at: updatedAt archived_at: archivedAt issue_id: issue { id } release_id: release { id }`,
+	item: IssueToReleaseObjectSchema,
+	updatedAt: (link) => link.updated_at,
+	rows: rowsOf((link) => ({
+		...link,
+		version: link.updated_at
+	}))
+});
+const makeIssueToReleases = (client) => Resource.entity({
+	name: "issue_to_releases",
+	rowSchema: IssueToReleaseSchema,
+	version: "version",
+	check: checkList(client, issueToReleaseSpec),
+	backfill: backfillList(client, issueToReleaseSpec),
+	changes: changesList(client, issueToReleaseSpec)
+});
+//#endregion
+//#region src/schemas/teams.ts
+const TeamSchema = Schema.Struct({
+	...common("Team"),
+	name: Schema.String.pipe(field(10, "Team name.")),
+	key: Schema.String.pipe(field(11, "Team key, used in issue IDs such as ENG-123.")),
+	display_name: Schema.String.pipe(field(12, "Name shown in Linear.")),
+	description: OptionalString.pipe(field(13, "Team description.")),
+	visibility: Schema.String.pipe(field(14, "Who can see the team.")),
+	parent_id: OptionalRef.pipe(field(15, "Parent team.")),
+	timezone: Schema.String.pipe(field(16, "Team timezone.")),
+	cycles_enabled: Schema.Boolean.pipe(field(17, "Whether the team uses cycles.")),
+	cycle_duration: Schema.Finite.pipe(field(18, "Cycle length in weeks.")),
+	cycle_cooldown_time: Schema.Finite.pipe(field(19, "Weeks between cycles.")),
+	cycle_start_day: Schema.Finite.pipe(field(20, "Day cycles start, 0 for Sunday.")),
+	triage_enabled: Schema.Boolean.pipe(field(21, "Whether the team uses triage.")),
+	issue_estimation_type: Schema.String.pipe(field(22, "Estimate scale.")),
+	default_issue_estimate: Schema.Finite.pipe(field(23, "Default estimate.")),
+	auto_archive_period: Schema.Finite.pipe(field(24, "Months before closed issues are archived.")),
+	auto_close_period: Schema.NullOr(Schema.Finite).pipe(field(25, "Months before stale issues are closed.")),
+	retired_at: OptionalTimestamp.pipe(field(26, "Time the team was retired."))
+}).annotate({ description: "Linear teams." }).pipe(Iceberg.identifier("id"));
+const TeamObjectSchema = TeamSchema.mapFields((fields) => Struct.omit(fields, ["version"]));
+const TeamMembershipSchema = Schema.Struct({
+	...common("Membership"),
+	team_id: Ref.pipe(field(10, "Team.")),
+	user_id: Ref.pipe(field(11, "User.")),
+	owner: Schema.Boolean.pipe(field(12, "Whether the user owns the team."))
+}).annotate({ description: "Linear team members. Removed members aren't seen." }).pipe(Iceberg.identifier("id"));
+const TeamMembershipObjectSchema = TeamMembershipSchema.mapFields((fields) => Struct.omit(fields, ["version"]));
+const WorkflowStateSchema = Schema.Struct({
+	...common("Workflow state"),
+	name: Schema.String.pipe(field(10, "State name.")),
+	type: Schema.String.pipe(field(11, "State type: triage, backlog, unstarted, started, completed, or canceled.")),
+	color: Schema.String.pipe(field(12, "State color, as hex.")),
+	description: OptionalString.pipe(field(13, "State description.")),
+	position: Schema.Finite.pipe(field(14, "Order within the team.")),
+	team_id: Ref.pipe(field(15, "Team."))
+}).annotate({ description: "Linear workflow states. Names the IDs in `issues.state_id`." }).pipe(Iceberg.identifier("id"));
+const WorkflowStateObjectSchema = WorkflowStateSchema.mapFields((fields) => Struct.omit(fields, ["version"]));
+const UserSchema = Schema.Struct({
+	...common("User"),
+	_deleted: deleted("user"),
+	name: Schema.String.pipe(field(10, "Full name.")),
+	display_name: Schema.String.pipe(field(11, "Display name.")),
+	email: Schema.String.pipe(field(12, "Email address.")),
+	avatar_url: OptionalString.pipe(field(13, "Avatar image URL.")),
+	title: OptionalString.pipe(field(14, "Job title.")),
+	timezone: OptionalString.pipe(field(15, "Timezone.")),
+	active: Schema.Boolean.pipe(field(16, "Whether the user is active.")),
+	admin: Schema.Boolean.pipe(field(17, "Whether the user is an admin.")),
+	owner: Schema.Boolean.pipe(field(18, "Whether the user owns the workspace.")),
+	guest: Schema.Boolean.pipe(field(19, "Whether the user is a guest.")),
+	app: Schema.Boolean.pipe(field(20, "Whether the user is an app or agent.")),
+	last_seen: OptionalTimestamp.pipe(field(21, "Time the user was last online.")),
+	url: Schema.String.pipe(field(22, "Profile URL."))
+}).annotate({ description: "Linear users." }).pipe(Iceberg.identifier("id"));
+const UserObjectSchema = UserSchema.mapFields((fields) => Struct.omit(fields, ["version", "_deleted"]));
+const ExternalUserSchema = Schema.Struct({
+	...common("External user"),
+	name: Schema.String.pipe(field(10, "Name.")),
+	display_name: Schema.String.pipe(field(11, "Display name.")),
+	email: OptionalString.pipe(field(12, "Email address.")),
+	avatar_url: OptionalString.pipe(field(13, "Avatar image URL.")),
+	last_seen: OptionalTimestamp.pipe(field(14, "Time the user was last seen."))
+}).annotate({ description: "People from integrations, such as Slack, who create issues and comments." }).pipe(Iceberg.identifier("id"));
+const ExternalUserObjectSchema = ExternalUserSchema.mapFields((fields) => Struct.omit(fields, ["version"]));
+const CycleSchema = Schema.Struct({
+	...common("Cycle"),
+	_deleted: deleted("cycle"),
+	number: Schema.Finite.pipe(field(10, "Cycle number within its team.")),
+	name: OptionalString.pipe(field(11, "Cycle name.")),
+	description: OptionalString.pipe(field(12, "Cycle description.")),
+	team_id: Ref.pipe(field(13, "Team.")),
+	starts_at: Timestamp.pipe(field(14, "Time the cycle starts.")),
+	ends_at: Timestamp.pipe(field(15, "Time the cycle ends.")),
+	completed_at: OptionalTimestamp.pipe(field(16, "Time the cycle was completed.")),
+	auto_archived_at: OptionalTimestamp.pipe(field(17, "Time the cycle was archived automatically.")),
+	progress: Schema.Finite.pipe(field(18, "Share of the scope completed, from 0 to 1."))
+}).annotate({ description: "Linear cycles." }).pipe(Iceberg.identifier("id"));
+const CycleObjectSchema = CycleSchema.mapFields((fields) => Struct.omit(fields, ["version", "_deleted"]));
+//#endregion
+//#region src/resources/teams.ts
+const teamSpec = listSpec({
+	connection: "teams",
+	fields: `id created_at: createdAt updated_at: updatedAt archived_at: archivedAt
+    name key display_name: displayName description visibility parent_id: parent { id }
+    timezone cycles_enabled: cyclesEnabled cycle_duration: cycleDuration
+    cycle_cooldown_time: cycleCooldownTime cycle_start_day: cycleStartDay
+    triage_enabled: triageEnabled issue_estimation_type: issueEstimationType
+    default_issue_estimate: defaultIssueEstimate auto_archive_period: autoArchivePeriod
+    auto_close_period: autoClosePeriod retired_at: retiredAt`,
+	item: TeamObjectSchema,
+	updatedAt: (team) => team.updated_at,
+	rows: rowsOf((team) => ({
+		...team,
+		version: team.updated_at
+	}))
+});
+const makeTeams = (client) => Resource.entity({
+	name: "teams",
+	rowSchema: TeamSchema,
+	version: "version",
+	...listSources(client, teamSpec)
+});
+const teamMembershipSpec = listSpec({
+	connection: "teamMemberships",
+	fields: `id created_at: createdAt updated_at: updatedAt archived_at: archivedAt team_id: team { id } user_id: user { id } owner`,
+	item: TeamMembershipObjectSchema,
+	updatedAt: (membership) => membership.updated_at,
+	rows: rowsOf((membership) => ({
+		...membership,
+		version: membership.updated_at
+	}))
+});
+const makeTeamMemberships = (client) => Resource.entity({
+	name: "team_memberships",
+	rowSchema: TeamMembershipSchema,
+	version: "version",
+	...listSources(client, teamMembershipSpec)
+});
+const workflowStateSpec = listSpec({
+	connection: "workflowStates",
+	fields: `id created_at: createdAt updated_at: updatedAt archived_at: archivedAt name type color description position team_id: team { id }`,
+	item: WorkflowStateObjectSchema,
+	updatedAt: (state) => state.updated_at,
+	rows: rowsOf((state) => ({
+		...state,
+		version: state.updated_at
+	}))
+});
+const makeWorkflowStates = (client) => Resource.entity({
+	name: "workflow_states",
+	rowSchema: WorkflowStateSchema,
+	version: "version",
+	...listSources(client, workflowStateSpec)
+});
+const userSpec = listSpec({
+	connection: "users",
+	single: "user",
+	fields: `id created_at: createdAt updated_at: updatedAt archived_at: archivedAt
+    name display_name: displayName email avatar_url: avatarUrl title timezone
+    active admin owner guest app last_seen: lastSeen url`,
+	item: UserObjectSchema,
+	updatedAt: (user) => user.updated_at,
+	rows: rowsOf((user) => ({
+		...user,
+		version: user.updated_at,
+		_deleted: false
+	}))
+});
+const makeUsers = (client) => Resource.entity({
+	name: "users",
+	rowSchema: UserSchema,
+	version: "version",
+	...listSources(client, userSpec),
+	webhook: webhookList(client, userSpec)
+});
+const externalUserSpec = listSpec({
+	connection: "externalUsers",
+	fields: `id created_at: createdAt updated_at: updatedAt archived_at: archivedAt name display_name: displayName email avatar_url: avatarUrl last_seen: lastSeen`,
+	item: ExternalUserObjectSchema,
+	updatedAt: (user) => user.updated_at,
+	rows: rowsOf((user) => ({
+		...user,
+		version: user.updated_at
+	}))
+});
+const makeExternalUsers = (client) => Resource.entity({
+	name: "external_users",
+	rowSchema: ExternalUserSchema,
+	version: "version",
+	...listSources(client, externalUserSpec)
+});
+const cycleSpec = listSpec({
+	connection: "cycles",
+	single: "cycle",
+	fields: `id created_at: createdAt updated_at: updatedAt archived_at: archivedAt
+    number name description team_id: team { id } starts_at: startsAt ends_at: endsAt
+    completed_at: completedAt auto_archived_at: autoArchivedAt progress`,
+	item: CycleObjectSchema,
+	updatedAt: (cycle) => cycle.updated_at,
+	rows: rowsOf((cycle) => ({
+		...cycle,
+		version: cycle.updated_at,
+		_deleted: false
+	}))
+});
+const makeCycles = (client) => Resource.entity({
+	name: "cycles",
+	rowSchema: CycleSchema,
+	version: "version",
+	check: checkList(client, cycleSpec),
+	backfill: backfillList(client, cycleSpec),
+	changes: changesList(client, cycleSpec),
+	webhook: webhookList(client, cycleSpec)
+});
+//#endregion
+//#region src/webhook/signature.ts
+const maxAgeMillis = 6e4;
+const verifySignature = (options) => Effect.gen(function* () {
+	const expected = createHmac("sha256", options.secret).update(options.rawBody).digest();
+	const provided = Buffer.from(options.header ?? "", "hex");
+	if (provided.length !== expected.length || !timingSafeEqual(provided, expected)) return yield* new ConnectorError({ message: "Invalid Linear webhook signature" });
+	const now = yield* DateTime.nowAsDate;
+	if (options.timestamp === void 0 || Math.abs(now.getTime() - options.timestamp) > maxAgeMillis) return yield* new ConnectorError({ message: "Linear webhook is too old" });
+});
+//#endregion
+//#region src/webhook/route.ts
+const webhookPath = "/webhooks/linear";
+const WebhookEventSchema = Schema.Struct({
+	type: Schema.String,
+	action: Schema.String,
+	webhookTimestamp: Schema.Number,
+	data: Schema.Struct({ id: Schema.String })
+});
+const makeWebhookRoute = (options) => Webhook.route({
+	path: webhookPath,
+	ackMode: "after-enqueue",
+	schema: WebhookEventSchema,
+	handler: ({ request, rawBody, payload, to }) => Effect.gen(function* () {
+		const verified = yield* verifySignature({
+			rawBody,
+			header: request.headers["linear-signature"],
+			secret: options.secret,
+			timestamp: payload.webhookTimestamp
+		}).pipe(Effect.result);
+		if (Result.isFailure(verified)) return HttpServerResponse.jsonUnsafe({
+			ok: false,
+			error: verified.failure.message
+		}, { status: 401 });
+		const resource = options.targets.get(payload.type);
+		if (payload.action === "remove" || payload.action === "restore") {
+			if (resource !== void 0) yield* to(resource, payload);
+			if (payload.type === "Issue") yield* to(options.issueHistory, payload);
+		}
+		return HttpServerResponse.jsonUnsafe({ ok: true });
+	})
+});
+//#endregion
+//#region src/connector.ts
+var connector_exports = /* @__PURE__ */ __exportAll({
+	LinearConfigDef: () => LinearConfigDef,
+	LinearConnector: () => LinearConnector,
+	layer: () => layer,
+	layerConfig: () => layerConfig,
+	make: () => make,
+	manifest: () => manifest
+});
+const make = Effect.fnUntraced(function* (config) {
+	const client = yield* LinearClient;
+	const Issues = makeIssues(client);
+	const IssueHistory = makeIssueHistory(client);
+	const Comments = makeComments(client);
+	const Attachments = makeAttachments(client);
+	const IssueLabels = makeIssueLabels(client);
+	const Users = makeUsers(client);
+	const Cycles = makeCycles(client);
+	const Projects = makeProjects(client);
+	const ProjectUpdates = makeProjectUpdates(client);
+	const ProjectLabels = makeProjectLabels(client);
+	const Initiatives = makeInitiatives(client);
+	const InitiativeUpdates = makeInitiativeUpdates(client);
+	const Documents = makeDocuments(client);
+	const Customers = makeCustomers(client);
+	const CustomerNeeds = makeCustomerNeeds(client);
+	return Connector.define({
+		name: "producer-linear",
+		title: "Linear",
+		resources: [
+			Issues,
+			IssueHistory,
+			Comments,
+			makeIssueRelations(client),
+			Attachments,
+			IssueLabels,
+			makeWorkflowStates(client),
+			makeTeams(client),
+			makeTeamMemberships(client),
+			Users,
+			makeExternalUsers(client),
+			Cycles,
+			Projects,
+			makeProjectMilestones(client),
+			ProjectUpdates,
+			makeProjectStatuses(client),
+			ProjectLabels,
+			makeProjectRelations(client),
+			Initiatives,
+			InitiativeUpdates,
+			makeInitiativeLabels(client),
+			makeInitiativeRelations(client),
+			makeInitiativeToProjects(client),
+			Documents,
+			Customers,
+			CustomerNeeds,
+			makeCustomerStatuses(client),
+			makeCustomerTiers(client),
+			makeReleases(client),
+			makeReleaseNotes(client),
+			makeReleasePipelines(client),
+			makeReleaseStages(client),
+			makeIssueToReleases(client)
+		],
+		webhooks: [makeWebhookRoute({
+			secret: Redacted.value(config.webhookSecret),
+			issueHistory: IssueHistory,
+			targets: /* @__PURE__ */ new Map([
+				["Issue", Issues],
+				["Comment", Comments],
+				["Attachment", Attachments],
+				["IssueLabel", IssueLabels],
+				["User", Users],
+				["Cycle", Cycles],
+				["Project", Projects],
+				["ProjectUpdate", ProjectUpdates],
+				["ProjectLabel", ProjectLabels],
+				["Initiative", Initiatives],
+				["InitiativeUpdate", InitiativeUpdates],
+				["Document", Documents],
+				["Customer", Customers],
+				["CustomerNeed", CustomerNeeds]
+			])
+		})]
+	});
+});
+var LinearConnector = class extends Context.Service()("@useairfoil/producer-linear/LinearConnector") {};
+const layer = (config) => Layer.effect(LinearConnector)(make(config).pipe(Effect.annotateLogs({ component: "linear" }))).pipe(Layer.provide(layer$1(config)));
+const layerConfig = (config) => Layer.unwrap(Config.unwrap(config).pipe(Effect.map(layer)));
+//#endregion
+export { InitiativeToProjectSchema as A, IssueHistorySchema as C, InitiativeLabelSchema as D, IssueSchema as E, CustomerStatusSchema as F, CustomerTierSchema as I, CommentSchema as L, DocumentSchema as M, CustomerNeedSchema as N, InitiativeRelationSchema as O, CustomerSchema as P, client_exports as R, AttachmentSchema as S, IssueRelationSchema as T, ProjectMilestoneSchema as _, CycleSchema as a, ProjectStatusSchema as b, TeamSchema as c, IssueToReleaseSchema as d, ReleaseNoteSchema as f, ProjectLabelSchema as g, ReleaseStageSchema as h, webhookPath as i, InitiativeUpdateSchema as j, InitiativeSchema as k, UserSchema as l, ReleaseSchema as m, connector_exports as n, ExternalUserSchema as o, ReleasePipelineSchema as p, layerConfig as r, TeamMembershipSchema as s, LinearConnector as t, WorkflowStateSchema as u, ProjectRelationSchema as v, IssueLabelSchema as w, ProjectUpdateSchema as x, ProjectSchema as y };
+
+//# sourceMappingURL=src-Ci3_ltan.mjs.map