@hraness/ghostget 0.17.2

package/src/providers/contact-projection.ts

@@ -0,0 +1,301 @@
+import { types as nodeTypes } from "node:util";
+
+export type ContactDirectionStatsLastAtBasis =
+  | "bounded-local-message-timestamp"
+  | "bounded-matched-message-internal-date"
+  | "unavailable";
+
+export type ContactDirectionStats = Readonly<{
+  count: number | null;
+  complete: boolean;
+  lowerBound: boolean;
+  truncated: boolean;
+  lastAt: string | null;
+  lastAtComplete: boolean;
+  lastAtBasis: ContactDirectionStatsLastAtBasis;
+  incompleteReasons: readonly string[];
+}>;
+
+export type ContactDirectionStatsProjection = Readonly<{
+  sentCount: number | null;
+  sentCountComplete: boolean;
+  sentCountLowerBound: boolean;
+  sentCountTruncated: boolean;
+  receivedCount: number | null;
+  receivedCountComplete: boolean;
+  receivedCountLowerBound: boolean;
+  receivedCountTruncated: boolean;
+  lastSentAt: string | null;
+  lastSentAtComplete: boolean;
+  lastSentAtBasis: ContactDirectionStatsLastAtBasis;
+  sentStatsIncompleteReasons: readonly string[];
+  lastReceivedAt: string | null;
+  lastReceivedAtComplete: boolean;
+  lastReceivedAtBasis: ContactDirectionStatsLastAtBasis;
+  receivedStatsIncompleteReasons: readonly string[];
+}>;
+
+type JsonRecord = Readonly<Record<string, unknown>>;
+
+const DIRECTION_STATS_KEYS = Object.freeze([
+  "count",
+  "complete",
+  "lowerBound",
+  "truncated",
+  "lastAt",
+  "lastAtComplete",
+  "lastAtBasis",
+  "incompleteReasons",
+] as const);
+const LAST_AT_BASES: ReadonlySet<unknown> = new Set<ContactDirectionStatsLastAtBasis>([
+  "bounded-local-message-timestamp",
+  "bounded-matched-message-internal-date",
+  "unavailable",
+]);
+const MAX_INCOMPLETE_REASONS = 32;
+const MAX_INCOMPLETE_REASON_LENGTH = 128;
+const INCOMPLETE_REASON_PATTERN = /^[a-z][a-z0-9]*(?:-[a-z0-9]+)*$/;
+const RFC3339_UTC_PATTERN = /^(\d{4})-(\d{2})-(\d{2})T(\d{2}):(\d{2}):(\d{2})(?:\.(\d{1,9}))?Z$/;
+
+function fail(label: string, message: string): never {
+  throw new Error(`${label} ${message}`);
+}
+
+function strictRecord(value: unknown, label: string): JsonRecord {
+  if (
+    nodeTypes.isProxy(value)
+    || typeof value !== "object"
+    || value === null
+    || Array.isArray(value)
+    || (
+      Object.getPrototypeOf(value) !== Object.prototype
+      && Object.getPrototypeOf(value) !== null
+    )
+  ) return fail(label, "must be a plain object");
+  const descriptors = Object.getOwnPropertyDescriptors(value);
+  for (const key of Reflect.ownKeys(descriptors)) {
+    if (typeof key !== "string") return fail(label, "must not contain symbol properties");
+    const descriptor = descriptors[key];
+    if (
+      descriptor === undefined
+      || !("value" in descriptor)
+      || !descriptor.enumerable
+    ) return fail(`${label}.${key}`, "must be an enumerable data property");
+  }
+  return value as JsonRecord;
+}
+
+function exactDirectionStatsKeys(value: JsonRecord, label: string): void {
+  const allowed = new Set<string>(DIRECTION_STATS_KEYS);
+  for (const key of Object.keys(value)) {
+    if (!allowed.has(key)) return fail(label, `contains unreviewed property ${key}`);
+  }
+  for (const key of DIRECTION_STATS_KEYS) {
+    if (!Object.hasOwn(value, key)) return fail(`${label}.${key}`, "is required");
+  }
+}
+
+function booleanValue(value: unknown, label: string): boolean {
+  if (typeof value !== "boolean") return fail(label, "must be boolean");
+  return value;
+}
+
+function countValue(value: unknown, label: string): number | null {
+  if (value === null) return null;
+  if (typeof value !== "number" || !Number.isSafeInteger(value) || value < 0) {
+    return fail(label, "must be null or a non-negative safe integer");
+  }
+  return value;
+}
+
+function isLeapYear(year: number): boolean {
+  return year % 4 === 0 && (year % 100 !== 0 || year % 400 === 0);
+}
+
+function daysInMonth(year: number, month: number): number {
+  if (month === 2) return isLeapYear(year) ? 29 : 28;
+  return month === 4 || month === 6 || month === 9 || month === 11 ? 30 : 31;
+}
+
+function rfc3339UtcValue(value: unknown, label: string): string | null {
+  if (value === null) return null;
+  if (typeof value !== "string") return fail(label, "must be null or an RFC 3339 UTC timestamp");
+  const match = RFC3339_UTC_PATTERN.exec(value);
+  if (match === null) return fail(label, "must be null or an RFC 3339 UTC timestamp");
+  const [, yearText, monthText, dayText, hourText, minuteText, secondText] = match;
+  const year = Number(yearText);
+  const month = Number(monthText);
+  const day = Number(dayText);
+  const hour = Number(hourText);
+  const minute = Number(minuteText);
+  const second = Number(secondText);
+  if (
+    !Number.isInteger(year)
+    || !Number.isInteger(month)
+    || !Number.isInteger(day)
+    || !Number.isInteger(hour)
+    || !Number.isInteger(minute)
+    || !Number.isInteger(second)
+    || month < 1
+    || month > 12
+    || day < 1
+    || day > daysInMonth(year, month)
+    || hour > 23
+    || minute > 59
+    || second > 60
+  ) return fail(label, "must be null or an RFC 3339 UTC timestamp");
+  return value;
+}
+
+function lastAtBasisValue(value: unknown, label: string): ContactDirectionStatsLastAtBasis {
+  if (!LAST_AT_BASES.has(value)) {
+    return fail(
+      label,
+      "must be bounded-local-message-timestamp, bounded-matched-message-internal-date, or unavailable",
+    );
+  }
+  return value as ContactDirectionStatsLastAtBasis;
+}
+
+function strictReasons(value: unknown, label: string): readonly string[] {
+  if (
+    nodeTypes.isProxy(value)
+    || !Array.isArray(value)
+    || Object.getPrototypeOf(value) !== Array.prototype
+  ) return fail(label, "must be a plain array");
+  if (value.length > MAX_INCOMPLETE_REASONS) {
+    return fail(label, `must contain at most ${MAX_INCOMPLETE_REASONS} reasons`);
+  }
+  const descriptors = Object.getOwnPropertyDescriptors(value);
+  for (const key of Reflect.ownKeys(descriptors)) {
+    if (typeof key !== "string") return fail(label, "must not contain symbol properties");
+    if (key === "length") continue;
+    const descriptor = descriptors[key];
+    if (
+      descriptor === undefined
+      || !("value" in descriptor)
+      || !descriptor.enumerable
+    ) return fail(`${label}.${key}`, "must be an enumerable data property");
+    const index = Number(key);
+    if (!Number.isSafeInteger(index) || index < 0 || String(index) !== key || index >= value.length) {
+      return fail(label, `contains unreviewed property ${key}`);
+    }
+  }
+  const reasons: string[] = [];
+  const seen = new Set<string>();
+  for (let index = 0; index < value.length; index += 1) {
+    if (!Object.hasOwn(value, index)) return fail(label, "must not be sparse");
+    const reason: unknown = value[index];
+    if (
+      typeof reason !== "string"
+      || reason.length === 0
+      || reason.length > MAX_INCOMPLETE_REASON_LENGTH
+      || !INCOMPLETE_REASON_PATTERN.test(reason)
+    ) {
+      return fail(
+        `${label}[${index}]`,
+        `must be a kebab-case reason of at most ${MAX_INCOMPLETE_REASON_LENGTH} code units`,
+      );
+    }
+    if (seen.has(reason)) return fail(label, `contains duplicate reason ${reason}`);
+    seen.add(reason);
+    reasons.push(reason);
+  }
+  return Object.freeze(reasons);
+}
+
+/** Parse and freeze one provider's completeness-aware sent or received statistics. */
+export function parseContactDirectionStats(
+  value: unknown,
+  label = "contact direction stats",
+): ContactDirectionStats {
+  const source = strictRecord(value, label);
+  exactDirectionStatsKeys(source, label);
+  const count = countValue(source.count, `${label}.count`);
+  const complete = booleanValue(source.complete, `${label}.complete`);
+  const lowerBound = booleanValue(source.lowerBound, `${label}.lowerBound`);
+  const truncated = booleanValue(source.truncated, `${label}.truncated`);
+  const lastAt = rfc3339UtcValue(source.lastAt, `${label}.lastAt`);
+  const lastAtComplete = booleanValue(source.lastAtComplete, `${label}.lastAtComplete`);
+  const lastAtBasis = lastAtBasisValue(source.lastAtBasis, `${label}.lastAtBasis`);
+  const incompleteReasons = strictReasons(
+    source.incompleteReasons,
+    `${label}.incompleteReasons`,
+  );
+
+  if (count === null && (complete || lowerBound || truncated)) {
+    return fail(label, "cannot mark an unavailable count complete, lower-bound, or truncated");
+  }
+  if (count !== null && complete === lowerBound) {
+    return fail(label, "a numeric count must be exactly complete or lower-bound");
+  }
+  if (lowerBound && complete) return fail(label, "a lower-bound count cannot be complete");
+  if (truncated && !lowerBound) return fail(label, "a truncated count must be a lower bound");
+  if (lastAt === null && lastAtBasis !== "unavailable") {
+    return fail(label, "must use an unavailable basis when lastAt is null");
+  }
+  if (lastAt !== null && lastAtBasis === "unavailable") {
+    return fail(label, "must identify a bounded basis when lastAt is available");
+  }
+  if (
+    lastAt === null
+    && lastAtComplete
+    && !(count === 0 && complete)
+  ) {
+    return fail(
+      label,
+      "can mark a missing lastAt complete only for an exactly complete zero count",
+    );
+  }
+  if (count === 0 && lastAt !== null) {
+    return fail(label, "cannot have lastAt when the observed count is zero");
+  }
+  if (count !== null && count > 0 && lastAtComplete && lastAt === null) {
+    return fail(label, "a complete lastAt for a positive count must be available");
+  }
+  const whollyComplete = complete && lastAtComplete;
+  if ((incompleteReasons.length === 0) !== whollyComplete) {
+    return fail(
+      label,
+      "must have no incomplete reasons exactly when both count and lastAt are complete",
+    );
+  }
+
+  return Object.freeze({
+    count,
+    complete,
+    lowerBound,
+    truncated,
+    lastAt,
+    lastAtComplete,
+    lastAtBasis,
+    incompleteReasons,
+  });
+}
+
+/** Project sent and received statistics into the stable flat contact output fields. */
+export function projectContactDirectionStats(
+  sentValue: unknown,
+  receivedValue: unknown,
+): ContactDirectionStatsProjection {
+  const sent = parseContactDirectionStats(sentValue, "sent contact direction stats");
+  const received = parseContactDirectionStats(receivedValue, "received contact direction stats");
+  return Object.freeze({
+    sentCount: sent.count,
+    sentCountComplete: sent.complete,
+    sentCountLowerBound: sent.lowerBound,
+    sentCountTruncated: sent.truncated,
+    receivedCount: received.count,
+    receivedCountComplete: received.complete,
+    receivedCountLowerBound: received.lowerBound,
+    receivedCountTruncated: received.truncated,
+    lastSentAt: sent.lastAt,
+    lastSentAtComplete: sent.lastAtComplete,
+    lastSentAtBasis: sent.lastAtBasis,
+    sentStatsIncompleteReasons: sent.incompleteReasons,
+    lastReceivedAt: received.lastAt,
+    lastReceivedAtComplete: received.lastAtComplete,
+    lastReceivedAtBasis: received.lastAtBasis,
+    receivedStatsIncompleteReasons: received.incompleteReasons,
+  });
+}

package/src/providers/github-read-model.ts

@@ -0,0 +1,94 @@
+import { GITHUB_API_ORIGIN, GITHUB_REPOSITORIES_PER_PAGE } from "./github-web";
+
+export function parseJson(
+  bytes: Uint8Array,
+  label: string
+
+): unknown {
+  if (bytes.byteLength === 0) {
+    throw new Error(`${label} was empty`);
+  }
+  let text: string;
+  try {
+    text = new TextDecoder("utf-8", { fatal: true }).decode(bytes);
+  } catch {
+    throw new Error(`${label} was not valid UTF-8`);
+  }
+  try {
+    return JSON.parse(text) as unknown;
+  } catch {
+    throw new Error(`${label} was not valid JSON`);
+  }
+}
+
+export function organizationRepositoriesUrl(
+  organization: string,
+  page: number
+
+): URL {
+  const url = new URL(`/orgs/${organization}/repos`, GITHUB_API_ORIGIN);
+  url.searchParams.set("type", "public");
+  url.searchParams.set("per_page", String(GITHUB_REPOSITORIES_PER_PAGE));
+  url.searchParams.set("page", String(page));
+  return url;
+}
+
+export function exactNextPageLink(
+  raw: string | null,
+  organization: string,
+  expectedPage: number,
+
+): boolean {
+  if (raw === null) return false;
+  let next = false;
+  for (const segment of raw.split(",")) {
+    const match = /^<([^<>]+)>;\s*rel="(first|last|next|prev)"$/u.exec(
+      segment.trim(),
+    );
+    if (match === null) {
+      throw new Error("GitHub organization repository pagination header drifted");
+    }
+    if (match[2] !== "next") continue;
+    if (next) {
+      throw new Error("GitHub organization repository pagination repeated next page");
+    }
+    const nextTarget = match[1];
+    if (nextTarget === undefined) {
+      throw new Error("GitHub organization repository pagination next link was invalid");
+    }
+    let url: URL;
+    try {
+      url = new URL(nextTarget);
+    } catch {
+      throw new Error("GitHub organization repository pagination next link was invalid");
+    }
+    const expected = organizationRepositoriesUrl(organization, expectedPage);
+    const keys = [...url.searchParams.keys()].sort();
+    if (
+      url.origin !== expected.origin
+      || url.pathname !== expected.pathname
+      || url.username !== ""
+      || url.password !== ""
+      || url.hash !== ""
+      || keys.join(",") !== "page,per_page,type"
+      || url.searchParams.getAll("page").join(",") !== String(expectedPage)
+      || url.searchParams.getAll("per_page").join(",")
+      !== String(GITHUB_REPOSITORIES_PER_PAGE)
+      || url.searchParams.getAll("type").join(",") !== "public"
+    ) {
+      throw new Error("GitHub organization repository pagination next link drifted");
+    }
+    next = true;
+  }
+  return next;
+}
+
+export function repositoryPage(value: unknown): readonly unknown[] {
+  if (
+    !Array.isArray(value)
+    || value.length > GITHUB_REPOSITORIES_PER_PAGE
+  ) {
+    throw new Error("GitHub organization repository page was not one bounded array");
+  }
+  return Object.freeze([...value]);
+}

package/src/providers/github-read-platform.ts

@@ -0,0 +1,165 @@
+import * as Context from "effect/Context";
+import * as Effect from "effect/Effect";
+import * as Layer from "effect/Layer";
+import type { WebSessionRecipe } from "../model";
+import { OperationDeadlineError } from "../operation-deadline";
+import { pinnedHttpsFetch, type PinnedHttpsFetch } from "../pinned-https";
+import { readAttempt, ReadEffectFailure, withReadResource } from "../read-effect";
+import type { WebSessionOperationDeadline } from "../web-session-execution";
+import { parseJson } from "./github-read-model";
+import {
+  ProviderReadResponseRejectedError,
+  ProviderReadThrottledError,
+  ProviderReadTransportError
+} from "./read-failure";
+
+export type GitHubReadRequest = {
+  readonly url: URL;
+  readonly userAgent: string;
+  readonly operationLabel: string;
+  readonly apiLabel: string;
+  readonly responseLabel: string;
+  readonly pagination: boolean;
+};
+
+export type GitHubReadDependencies = { readonly fetch?: PinnedHttpsFetch; readonly now?: () => number; };
+
+export class GitHubReadPlatform extends Context.Tag("wrench/GitHubReadPlatform/v1")<GitHubReadPlatform, {
+  readonly request: (request: GitHubReadRequest) => Effect.Effect<{ readonly value: unknown; readonly link: string | null; }, ReadEffectFailure>;
+  readonly observedAt: Effect.Effect<string, ReadEffectFailure>;
+}>() { }
+
+const native = <A>(work: () => Promise<A>): Effect.Effect<A, ReadEffectFailure> =>
+  Effect.tryPromise({ try: work, catch: cause => new ReadEffectFailure({ cause }) });
+
+export function GitHubReadPlatformLive(
+  recipe: WebSessionRecipe,
+  dependencies: GitHubReadDependencies | undefined,
+  deadline: WebSessionOperationDeadline | undefined
+
+): Layer.Layer<GitHubReadPlatform, ReadEffectFailure> {
+  return Layer.scoped(
+    GitHubReadPlatform,
+    Effect.gen(function*() {
+      const operation = yield* Effect.acquireRelease(
+        readAttempt(() => {
+          if (deadline !== undefined) return { signal: deadline.signal, dispose: () => { } };
+          const controller = new AbortController();
+          const timeout = setTimeout(() => controller.abort(), recipe.timeoutMs);
+          return { signal: controller.signal, dispose: () => clearTimeout(timeout) };
+        }),
+        operation => Effect.sync(operation.dispose)
+      );
+      const fetch = dependencies?.fetch ?? pinnedHttpsFetch;
+      const maximum = Math.min(recipe.maxOutputBytes, 2 * 1024 * 1024);
+      return {
+        observedAt: readAttempt(() => new Date(dependencies?.now?.() ?? Date.now()).toISOString()),
+        request: (request: GitHubReadRequest) => Effect.gen(function*() {
+          const timeout = yield* readAttempt(() => {
+            deadline?.throwIfUnavailable(request.operationLabel);
+            const remaining = Math.min(recipe.timeoutMs, deadline?.remainingTimeMs() ?? recipe.timeoutMs);
+            if (remaining < 1_000) throw new OperationDeadlineError(request.operationLabel, "timed-out");
+            return remaining;
+          });
+          const response = yield* native(() => fetch(
+            request.url,
+            {
+              method: "GET",
+              headers: {
+                accept: "application/vnd.github+json",
+                "user-agent": request.userAgent,
+                "x-github-api-version": "2026-03-10"
+              },
+              redirect: "error",
+              signal: operation.signal,
+            },
+            timeout
+          )).pipe(Effect.mapError(error => {
+            if (operation.signal.aborted) {
+              try { deadline?.throwIfUnavailable(request.operationLabel); }
+              catch (cause) { return new ReadEffectFailure({ cause }); }
+              return new ReadEffectFailure({ cause: new OperationDeadlineError(request.operationLabel, "timed-out") });
+            }
+            return new ReadEffectFailure({ cause: new ProviderReadTransportError(error.cause) });
+          }));
+          const metadata = yield* readAttempt(() => {
+            if (response.status !== 200) {
+              const retryAfter = response.headers.get("retry-after");
+              if (response.status === 403
+                && (response.headers.get("x-ratelimit-remaining") === "0"
+                  || (retryAfter !== null && /^(?:0|[1-9][0-9]{0,8})$/u.test(retryAfter)))) throw new ProviderReadThrottledError();
+              throw new ProviderReadResponseRejectedError(response.status);
+            }
+            const type = response.headers.get("content-type")?.split(";", 1)[0]?.trim().toLowerCase();
+            if (type !== "application/json" && type?.endsWith("+json") !== true) throw new Error(`${request.apiLabel} returned an unreviewed content type`);
+            const link = request.pagination ? response.headers.get("link") : null;
+            if (link !== null && (link.length > 8 * 1024 || /[\0\r\n]/u.test(link))) throw new Error("GitHub organization repository pagination header exceeded its reviewed bounds");
+            const declared = response.headers.get("content-length");
+            if (declared !== null) {
+              const length = Number(declared);
+              if (!Number.isSafeInteger(length) || length < 0 || length > maximum) throw new Error(`${request.responseLabel} exceeded its byte limit`);
+            }
+            return link;
+          }).pipe(Effect.catchTag(
+            "ReadEffectFailure",
+            primary => native(() => response.body?.cancel() ?? Promise.resolve()).pipe(
+              Effect.timeoutFail({
+                duration: 500,
+                onTimeout: () => new ReadEffectFailure({ cause: new Error("GitHub response cleanup did not settle") })
+              }),
+              Effect.matchEffect({
+                onFailure: cleanup => Effect.fail(new ReadEffectFailure({ cause: primary.cause, cleanupCause: cleanup.cause })),
+                onSuccess: () => Effect.fail(primary)
+              })
+            )
+          ));
+          const bytes = response.body === null
+            ? new Uint8Array()
+            : yield* withReadResource(
+              readAttempt(() => response.body!.getReader()),
+              reader => Effect.gen(function*() {
+                const chunks: Uint8Array[] = [];
+                let length = 0;
+                while (true) {
+                  const result = yield* native(() => deadline === undefined
+                    ? reader.read()
+                    : deadline.run(() => reader.read(), request.responseLabel)).pipe(
+                      Effect.mapError(error => error.cause instanceof OperationDeadlineError
+                        ? error
+                        : new ReadEffectFailure({ cause: new ProviderReadTransportError(error.cause) })),
+                    );
+                  if (result.done) break;
+                  yield* readAttempt(() => {
+                    if (!(result.value instanceof Uint8Array)) throw new Error(`${request.responseLabel} returned an unreviewed body chunk`);
+                    length += result.value.byteLength;
+                    if (length > maximum) throw new Error(`${request.responseLabel} exceeded its byte limit`);
+                    chunks.push(result.value);
+                  });
+                }
+                return yield* readAttempt(() => {
+                  const joined = new Uint8Array(length);
+                  let offset = 0;
+                  for (const chunk of chunks) { joined.set(chunk, offset); offset += chunk.byteLength; }
+                  return joined;
+                });
+              }).pipe(Effect.catchTag(
+                "ReadEffectFailure",
+                primary => native(() => reader.cancel()).pipe(
+                  Effect.timeoutFail({
+                    duration: 500,
+                    onTimeout: () => new ReadEffectFailure({ cause: new Error("GitHub response cleanup did not settle") })
+                  }),
+                  Effect.matchEffect({
+                    onFailure: cleanup => Effect.fail(new ReadEffectFailure({ cause: primary.cause, cleanupCause: cleanup.cause })),
+                    onSuccess: () => Effect.fail(primary)
+                  })
+                )
+              )),
+              reader => readAttempt(() => reader.releaseLock()),
+            );
+          return { value: yield* readAttempt(() => parseJson(bytes, request.responseLabel)), link: metadata };
+        }),
+      };
+    })
+  );
+}

package/src/providers/github-read-program.ts

@@ -0,0 +1,97 @@
+import * as Effect from "effect/Effect";
+import { readAttempt, type ReadEffectFailure } from "../read-effect";
+import {
+  readFailureProjection,
+  type WebSessionExecution,
+} from "../web-session-execution";
+import { GitHubReadPlatform } from "./github-read-platform";
+import {
+  exactNextPageLink,
+  organizationRepositoriesUrl,
+  repositoryPage
+} from "./github-read-model";
+import {
+  GITHUB_API_ORIGIN,
+  GITHUB_MAX_ORGANIZATION_REPOSITORIES,
+  GITHUB_MAX_ORGANIZATION_REPOSITORY_PAGES,
+  GITHUB_REPOSITORIES_PER_PAGE,
+  parseGitHubOrganizationRead,
+  projectGitHubOrganizationRepository,
+  projectGitHubOrganizationStats
+} from "./github-web";
+import { failedProviderRead, type ProviderReadFailureStage } from "./read-failure";
+
+export function githubOrganizationReadProgram(requestedOrganization: string): Effect.Effect<WebSessionExecution, ReadEffectFailure, GitHubReadPlatform> {
+  return Effect.gen(function*() {
+    const platform = yield* GitHubReadPlatform;
+    let stage: ProviderReadFailureStage = "target";
+    return yield* Effect.gen(function*() {
+      const organizationResponse = yield* platform.request({
+        url: new URL(`/orgs/${requestedOrganization}`, GITHUB_API_ORIGIN),
+        userAgent: "wrench-github-organization-stats/1.1.0",
+        operationLabel: "GitHub public organization statistics read deadline",
+        apiLabel: "GitHub public organization API",
+        responseLabel: "GitHub organization response",
+        pagination: false,
+      });
+      const organization = yield* readAttempt(() => parseGitHubOrganizationRead(organizationResponse.value, requestedOrganization));
+      const pageCount = yield* readAttempt(() => {
+        if (organization.publicRepositories > GITHUB_MAX_ORGANIZATION_REPOSITORIES) throw new Error("GitHub organization public repository count exceeded the reviewed pagination bound");
+        const count = Math.ceil(organization.publicRepositories / GITHUB_REPOSITORIES_PER_PAGE);
+        if (count > GITHUB_MAX_ORGANIZATION_REPOSITORY_PAGES) throw new Error("GitHub organization public repository page count exceeded the reviewed pagination bound");
+        return count;
+      });
+      const repositoryIds = new Set<number>();
+      let totalStars = 0;
+      stage = "supplemental";
+      for (let page = 1; page <= pageCount; page += 1) {
+        const response = yield* platform.request({
+          url: organizationRepositoriesUrl(organization.organization, page),
+          userAgent: "wrench-github-organization-stats/1.1.0",
+          operationLabel: "GitHub public organization statistics read deadline",
+          apiLabel: "GitHub public organization repository API",
+          responseLabel: "GitHub organization repository response",
+          pagination: true,
+        });
+        yield* readAttempt(() => {
+          const repositories = repositoryPage(response.value);
+          const remaining = organization.publicRepositories - (page - 1) * GITHUB_REPOSITORIES_PER_PAGE;
+          if (repositories.length !== Math.min(GITHUB_REPOSITORIES_PER_PAGE, remaining)) throw new Error("GitHub organization repository page did not complete the declared public repository set");
+          if (exactNextPageLink(response.link, organization.organization, page + 1) !== (page < pageCount)) throw new Error("GitHub organization repository pagination did not complete the declared public repository set");
+          for (const value of repositories) {
+            const repository = projectGitHubOrganizationRepository(value, organization);
+            if (repositoryIds.has(repository.id)) throw new Error("GitHub organization repository pagination repeated one repository");
+            repositoryIds.add(repository.id);
+            if (repository.stars > Number.MAX_SAFE_INTEGER - totalStars) throw new Error("GitHub organization star total exceeded a safe integer");
+            totalStars += repository.stars;
+          }
+        });
+      }
+      const observedAt = yield* platform.observedAt;
+      const output = yield* readAttempt(() => {
+        if (repositoryIds.size !== organization.publicRepositories) throw new Error("GitHub organization repository pagination did not complete the declared public repository set");
+        return projectGitHubOrganizationStats(organization, totalStars, observedAt);
+      });
+      return {
+        status: "succeeded" as const,
+        output,
+        finalUrl: output.target.url,
+        dispatchStarted: false,
+        dispatch: { planned: 0, started: 0, verified: 0 }
+      };
+    }).pipe(Effect.catchTag(
+      "ReadEffectFailure",
+      error => {
+        const failure = failedProviderRead(
+          "GitHub organization",
+          error.cause,
+          `https://github.com/${requestedOrganization}`,
+          { stage, authenticated: false, targetStatusUnavailable: true }
+        );
+        return Effect.succeed(Object.hasOwn(error, "cleanupCause")
+          ? { ...failure, readFailure: readFailureProjection("cleanup-required") }
+          : failure);
+      }
+    ));
+  });
+}