@sourceaxis/provider-github 0.1.0

package/dist/esm/index.js

@@ -0,0 +1,1112 @@
+import { anonymousAuth, createAuthContext, tokenAuth } from "@sourceaxis/auth";
+import { createSourceAxisClient } from "@sourceaxis/core";
+import { AuthenticationError, AuthorizationError, CapabilityNotSupportedError, ConflictError, SourceAxisError, NotFoundError, ProviderError, RateLimitError, TransportError, ValidationError } from "@sourceaxis/errors";
+import { deepFreeze } from "@sourceaxis/shared";
+import { createTransportResponse } from "@sourceaxis/transport";
+import { mapGitHubBranch, mapGitHubCommit, mapGitHubContentToBlob, mapGitHubContentToFileInfo, mapGitHubContentToTreeNode, mapGitHubIssue, mapGitHubPullRequest, mapGitHubRelease, mapGitHubRepository, mapGitHubSearchItem, mapGitHubTag, mapGitHubTree } from "./mappers.js";
+export { GitHubProviderId, GitHubProviderName, GitHubProviderVersion } from "./constants.js";
+import { GitHubProviderId, GitHubProviderName, GitHubProviderVersion } from "./constants.js";
+const foundationCapabilityDescriptors = deepFreeze([
+    {
+        name: "files",
+        operations: [
+            "readText",
+            "readJson",
+            "readBinary",
+            "download",
+            "exists",
+            "metadata",
+            "getMetadata"
+        ],
+        status: "supported"
+    },
+    {
+        name: "tree",
+        operations: ["list", "get", "tree"],
+        status: "supported"
+    },
+    {
+        name: "history",
+        operations: ["list", "get", "file"],
+        status: "supported"
+    },
+    {
+        name: "search",
+        operations: ["text", "query"],
+        status: "supported"
+    },
+    {
+        name: "branches",
+        operations: ["list", "get"],
+        status: "supported"
+    },
+    {
+        name: "tags",
+        operations: ["list", "get"],
+        status: "supported"
+    },
+    {
+        name: "issues",
+        operations: ["list", "get"],
+        status: "supported"
+    },
+    {
+        name: "pullRequests",
+        operations: ["list", "get"],
+        status: "supported"
+    },
+    {
+        name: "releases",
+        operations: ["list", "get"],
+        status: "supported"
+    }
+]);
+export const GitHubProviderCapabilities = deepFreeze({
+    branches: foundationCapabilityDescriptors[4],
+    files: foundationCapabilityDescriptors[0],
+    history: foundationCapabilityDescriptors[2],
+    issues: foundationCapabilityDescriptors[6],
+    pullRequests: foundationCapabilityDescriptors[7],
+    releases: foundationCapabilityDescriptors[8],
+    search: foundationCapabilityDescriptors[3],
+    tags: foundationCapabilityDescriptors[5],
+    tree: foundationCapabilityDescriptors[1]
+});
+/**
+ * Creates the GitHub provider implementation for explicit Core registration.
+ */
+export function createGitHubProvider(config = {}) {
+    return new GitHubProvider(config);
+}
+/**
+ * Creates the GitHub provider with a short, discoverable name for application setup.
+ */
+export function githubProvider(config = {}) {
+    return createGitHubProvider(config);
+}
+/**
+ * Creates a SourceAxis client config fragment containing the GitHub provider.
+ */
+export function createGitHubProviderConfig(config = {}) {
+    return {
+        providers: [createGitHubProvider(config)]
+    };
+}
+/**
+ * Creates a GitHub-scoped token authentication strategy for SourceAxis clients.
+ */
+export function githubTokenAuth(token, options = {}) {
+    return Object.freeze({
+        type: "token",
+        async authenticate(request) {
+            if (request?.provider !== undefined && request.provider !== GitHubProviderId) {
+                return createAuthContext(anonymousAuth({ provider: request.provider }));
+            }
+            return createAuthContext(tokenAuth({ ...options, provider: GitHubProviderId, token }));
+        }
+    });
+}
+/**
+ * Creates a SourceAxis client with the GitHub provider registered.
+ */
+export function createGitHubClient(config = {}) {
+    const { authentication, token, ...providerConfig } = config;
+    const resolvedProviderConfig = {
+        ...providerConfig,
+        transport: providerConfig.transport ?? createGitHubHttpTransport()
+    };
+    return createSourceAxisClient({
+        ...createGitHubProviderConfig(resolvedProviderConfig),
+        authentication: authentication ?? (token === undefined ? undefined : githubTokenAuth(token))
+    });
+}
+export class GitHubProvider {
+    #config;
+    #hosts;
+    info;
+    constructor(config = {}) {
+        this.#hosts = deepFreeze(normalizeHosts(config.hosts ?? ["github.com"]));
+        this.#config = Object.freeze({
+            ...config,
+            hosts: this.#hosts
+        });
+        this.info = deepFreeze({
+            capabilities: GitHubProviderCapabilities,
+            id: GitHubProviderId,
+            metadata: config.metadata,
+            name: GitHubProviderName,
+            priority: config.priority,
+            version: GitHubProviderVersion
+        });
+    }
+    async supports(locator) {
+        const location = parseGitHubRepositoryUrl(locator.url, this.#hosts);
+        if (location === undefined) {
+            return deepFreeze({ confidence: "none", provider: GitHubProviderId });
+        }
+        return deepFreeze({
+            confidence: "exact",
+            metadata: { provider: GitHubProviderId, extra: { host: location.host } },
+            provider: GitHubProviderId,
+            repository: toRepositoryIdentity(location)
+        });
+    }
+    async createSession(request) {
+        return runGitHubProviderOperation("provider.session.create", async () => {
+            const location = resolveRepositoryLocation(request.repository, this.#hosts);
+            const dependencies = resolveDependencies(this.#config, request.context);
+            const context = createGitHubSessionContext(request.context, dependencies);
+            const requestContext = {
+                transport: dependencies.transport
+            };
+            if (context.authenticationContext !== undefined) {
+                requestContext.authentication = context.authenticationContext;
+            }
+            if (context.metadata !== undefined) {
+                requestContext.metadata = context.metadata;
+            }
+            const requestClient = createGitHubRequestClient(requestContext);
+            const fallback = toRepositoryInfo(location);
+            const repository = await readRepositoryInfo(requestClient, location, fallback);
+            return new GitHubProviderSession({
+                context,
+                requestClient,
+                repository
+            });
+        });
+    }
+}
+export class GitHubProviderSession {
+    #context;
+    #diagnosticSequence = 0;
+    #requestClient;
+    #state = "active";
+    capabilities;
+    provider = deepFreeze({
+        capabilities: GitHubProviderCapabilities,
+        id: GitHubProviderId,
+        name: GitHubProviderName,
+        version: GitHubProviderVersion
+    });
+    repository;
+    constructor(input) {
+        this.#context = Object.freeze(input.context);
+        this.#requestClient = input.requestClient;
+        this.repository = deepFreeze(input.repository);
+        this.capabilities = createFoundationCapabilities(this.repository.identity, this.#requestClient, () => this.ensureActive());
+    }
+    get state() {
+        return this.#state;
+    }
+    get context() {
+        return this.#context;
+    }
+    async getCapabilities() {
+        this.ensureActive();
+        return foundationCapabilityDescriptors;
+    }
+    async dispose() {
+        if (this.#state === "disposed") {
+            return;
+        }
+        this.#state = "disposed";
+        await this.publishDiagnostic("provider.session.dispose");
+    }
+    ensureActive() {
+        if (this.#state === "disposed") {
+            throw new ProviderError("GitHub provider session has been disposed", {
+                diagnostics: {
+                    operation: { operation: "provider.session.lifecycle" },
+                    provider: { provider: GitHubProviderId },
+                    repository: formatRepositoryDiagnostics(this.repository.identity)
+                },
+                retryability: "Never"
+            });
+        }
+    }
+    async publishDiagnostic(name) {
+        try {
+            await this.#context.diagnostics?.publish(deepFreeze({
+                context: {
+                    provider: GitHubProviderId,
+                    repository: `${this.repository.identity.owner}/${this.repository.identity.name}`
+                },
+                id: `github-${name}-${++this.#diagnosticSequence}`,
+                kind: "provider",
+                name,
+                schemaVersion: "1.0",
+                timestamp: new Date().toISOString()
+            }));
+        }
+        catch {
+            // Diagnostics are observational and must not influence provider lifecycle.
+        }
+    }
+}
+function createGitHubRequestClient(context) {
+    return deepFreeze({
+        async request(request) {
+            const transportRequest = toTransportRequest(request, context);
+            try {
+                const transportContext = {};
+                if (context.metadata !== undefined) {
+                    transportContext.metadata = context.metadata;
+                }
+                const response = await context.transport.execute(transportRequest, transportContext);
+                return fromTransportResponse(response);
+            }
+            catch (error) {
+                throw mapGitHubError(error, "github.transport.request");
+            }
+        }
+    });
+}
+async function readRepositoryInfo(requestClient, location, fallback) {
+    const response = await requestGitHubResponse(requestClient, "github.repository.get", `/repos/${encodePathPart(location.owner)}/${encodePathPart(location.name)}`);
+    if (response.data === undefined || response.status === 204) {
+        return fallback;
+    }
+    return mapGitHubRepository(response.data, fallback.identity);
+}
+async function readContent(requestClient, repository, path, operation) {
+    const response = await requestGitHub(requestClient, operation, `/repos/${encodePathPart(repository.owner)}/${encodePathPart(repository.name)}/contents/${encodeRepositoryPath(path)}`);
+    if (Array.isArray(response)) {
+        throw new ValidationError("GitHub content response is a directory, not a file", {
+            diagnostics: {
+                operation: { operation },
+                provider: { provider: GitHubProviderId },
+                repository: formatRepositoryDiagnostics(repository)
+            }
+        });
+    }
+    return response;
+}
+async function requestGitHub(requestClient, operation, url) {
+    const response = await requestGitHubResponse(requestClient, operation, url);
+    if (response.data === undefined) {
+        throw new ProviderError("GitHub response did not include a response body", {
+            diagnostics: {
+                operation: { operation },
+                provider: { provider: GitHubProviderId, status: response.status }
+            },
+            retryability: "Maybe"
+        });
+    }
+    return response.data;
+}
+async function requestGitHubResponse(requestClient, operation, url) {
+    try {
+        const response = await requestClient.request({ method: "GET", url });
+        if (response.status === 404) {
+            throw new NotFoundError("GitHub resource was not found", {
+                diagnostics: {
+                    operation: { operation },
+                    provider: { provider: GitHubProviderId, status: response.status }
+                },
+                retryability: "Never"
+            });
+        }
+        if (response.status < 200 || response.status >= 300) {
+            throw createGitHubStatusError(response.status, operation, response.headers);
+        }
+        return response;
+    }
+    catch (error) {
+        throw mapGitHubError(error, operation);
+    }
+}
+export function mapGitHubError(error, operation = "github.provider") {
+    if (error instanceof SourceAxisError) {
+        return error;
+    }
+    const status = getErrorStatus(error);
+    const providerDiagnostics = {
+        provider: GitHubProviderId
+    };
+    const providerCode = getErrorCode(error);
+    if (providerCode !== undefined) {
+        providerDiagnostics.providerCode = providerCode;
+    }
+    const requestId = getErrorRequestId(error);
+    if (requestId !== undefined) {
+        providerDiagnostics.requestId = requestId;
+    }
+    if (status !== undefined) {
+        providerDiagnostics.status = status;
+    }
+    const diagnostics = {
+        operation: { operation },
+        provider: providerDiagnostics
+    };
+    if (status === 401) {
+        return new AuthenticationError("GitHub authentication failed", {
+            cause: error,
+            diagnostics,
+            retryability: "Never"
+        });
+    }
+    if (status === 403 && isRateLimitError(error)) {
+        return new RateLimitError("GitHub rate limit exceeded", {
+            cause: error,
+            diagnostics,
+            retryability: "Always"
+        });
+    }
+    if (status === 403) {
+        return new AuthorizationError("GitHub authorization failed", {
+            cause: error,
+            diagnostics,
+            retryability: "Never"
+        });
+    }
+    if (status === 404) {
+        return new NotFoundError("GitHub resource was not found", {
+            cause: error,
+            diagnostics,
+            retryability: "Never"
+        });
+    }
+    if (status === 409) {
+        return new ConflictError("GitHub reported a resource conflict", {
+            cause: error,
+            diagnostics,
+            retryability: "Maybe"
+        });
+    }
+    if (status !== undefined && status >= 500) {
+        return new ProviderError("GitHub provider request failed", {
+            cause: error,
+            diagnostics,
+            retryability: "Maybe"
+        });
+    }
+    if (status !== undefined) {
+        return new ProviderError("GitHub provider rejected the request", {
+            cause: error,
+            diagnostics,
+            retryability: retryabilityForStatus(status)
+        });
+    }
+    return new ProviderError("GitHub provider operation failed", {
+        cause: error,
+        diagnostics,
+        retryability: "Maybe"
+    });
+}
+function createGitHubSessionContext(context, dependencies) {
+    return Object.freeze({
+        ...context,
+        cache: dependencies.cache,
+        diagnostics: dependencies.diagnostics,
+        provider: {
+            ...context.provider,
+            capabilities: GitHubProviderCapabilities
+        },
+        transport: dependencies.transport
+    });
+}
+function resolveDependencies(config, context) {
+    const dependencies = {
+        transport: config.transport ?? context.transport ?? createGitHubHttpTransport()
+    };
+    const cache = config.cache ?? context.cache;
+    const diagnostics = config.diagnostics ?? context.diagnostics;
+    if (cache !== undefined) {
+        dependencies.cache = cache;
+    }
+    if (diagnostics !== undefined) {
+        dependencies.diagnostics = diagnostics;
+    }
+    return dependencies;
+}
+function createFoundationCapabilities(repository, requestClient, ensureActive) {
+    const runtime = createGitHubRuntimeCapabilities(repository, requestClient, ensureActive);
+    return deepFreeze({
+        branches: runtime.branches,
+        files: runtime.files,
+        history: runtime.history,
+        issues: runtime.issues,
+        pullRequests: runtime.pullRequests,
+        releases: runtime.releases,
+        search: runtime.search,
+        tags: runtime.tags,
+        tree: runtime.tree
+    });
+}
+function createGitHubRuntimeCapabilities(repository, requestClient, ensureActive) {
+    return deepFreeze({
+        branches: createGitHubBranchesCapability(repository, requestClient, ensureActive),
+        files: createGitHubFilesCapability(repository, requestClient, ensureActive),
+        history: createGitHubHistoryCapability(repository, requestClient, ensureActive),
+        issues: createGitHubIssuesCapability(repository, requestClient, ensureActive),
+        pullRequests: createGitHubPullRequestsCapability(repository, requestClient, ensureActive),
+        releases: createGitHubReleasesCapability(repository, requestClient, ensureActive),
+        search: createGitHubSearchCapability(repository, requestClient, ensureActive),
+        tags: createGitHubTagsCapability(repository, requestClient, ensureActive),
+        tree: createGitHubTreeCapability(repository, requestClient, ensureActive)
+    });
+}
+function createGitHubBranchesCapability(repository, requestClient, ensureActive) {
+    return deepFreeze({
+        async get(name) {
+            ensureActive();
+            validateNonEmpty(name, "Branch name must be a non-empty string");
+            const response = await requestGitHub(requestClient, "github.branches.get", `/repos/${encodePathPart(repository.owner)}/${encodePathPart(repository.name)}/branches/${encodePathPart(name)}`);
+            return mapGitHubBranch(response, repository);
+        },
+        async list(_options) {
+            ensureActive();
+            const response = await requestGitHub(requestClient, "github.branches.list", `/repos/${encodePathPart(repository.owner)}/${encodePathPart(repository.name)}/branches`);
+            return createPage(response.map((branch) => mapGitHubBranch(branch, repository)));
+        }
+    });
+}
+function createGitHubTagsCapability(repository, requestClient, ensureActive) {
+    return deepFreeze({
+        async get(name) {
+            ensureActive();
+            validateNonEmpty(name, "Tag name must be a non-empty string");
+            const response = await requestGitHub(requestClient, "github.tags.get", `/repos/${encodePathPart(repository.owner)}/${encodePathPart(repository.name)}/git/ref/tags/${encodePathPart(name)}`);
+            return mapGitHubTag(response, repository);
+        },
+        async list(_options) {
+            ensureActive();
+            const response = await requestGitHub(requestClient, "github.tags.list", `/repos/${encodePathPart(repository.owner)}/${encodePathPart(repository.name)}/git/refs/tags`);
+            return createPage(response.map((tag) => mapGitHubTag(tag, repository)));
+        }
+    });
+}
+function createGitHubHistoryCapability(repository, requestClient, ensureActive) {
+    return deepFreeze({
+        async file(path, _options) {
+            ensureActive();
+            validatePath(path);
+            const response = await requestGitHub(requestClient, "github.history.file", `/repos/${encodePathPart(repository.owner)}/${encodePathPart(repository.name)}/commits?path=${encodeURIComponent(path)}`);
+            return createPage(response.map(mapGitHubCommit));
+        },
+        async get(sha) {
+            ensureActive();
+            validateNonEmpty(sha, "Commit sha must be a non-empty string");
+            const response = await requestGitHub(requestClient, "github.history.get", `/repos/${encodePathPart(repository.owner)}/${encodePathPart(repository.name)}/commits/${encodePathPart(sha)}`);
+            return mapGitHubCommit(response);
+        },
+        async list(_options) {
+            ensureActive();
+            const response = await requestGitHub(requestClient, "github.history.list", `/repos/${encodePathPart(repository.owner)}/${encodePathPart(repository.name)}/commits`);
+            return createPage(response.map(mapGitHubCommit));
+        }
+    });
+}
+function createGitHubTreeCapability(repository, requestClient, ensureActive) {
+    return deepFreeze({
+        async get(path) {
+            ensureActive();
+            validatePath(path);
+            const response = await requestGitHub(requestClient, "github.tree.get", `/repos/${encodePathPart(repository.owner)}/${encodePathPart(repository.name)}/contents/${encodeRepositoryPath(path)}`);
+            return mapGitHubContentToTreeNode(response);
+        },
+        async list(path) {
+            ensureActive();
+            validateOptionalPath(path);
+            const suffix = path === undefined ? "" : `/${encodeRepositoryPath(path)}`;
+            const response = await requestGitHub(requestClient, "github.tree.list", `/repos/${encodePathPart(repository.owner)}/${encodePathPart(repository.name)}/contents${suffix}`);
+            const items = Array.isArray(response) ? response : [response];
+            return deepFreeze(items.map(mapGitHubContentToTreeNode));
+        },
+        async tree(path) {
+            ensureActive();
+            validateOptionalPath(path);
+            const ref = path ?? "HEAD";
+            const response = await requestGitHub(requestClient, "github.tree.tree", `/repos/${encodePathPart(repository.owner)}/${encodePathPart(repository.name)}/git/trees/${encodePathPart(ref)}`);
+            return mapGitHubTree(response, path ?? "");
+        },
+        walk() {
+            ensureActive();
+            return rejectUnsupportedIterable("tree", repository);
+        }
+    });
+}
+function createGitHubFilesCapability(repository, requestClient, ensureActive) {
+    return deepFreeze({
+        async download(path) {
+            ensureActive();
+            validatePath(path);
+            const response = await readContent(requestClient, repository, path, "github.files.download");
+            return mapGitHubContentToBlob(response);
+        },
+        async exists(path) {
+            ensureActive();
+            validatePath(path);
+            try {
+                await readContent(requestClient, repository, path, "github.files.exists");
+                return true;
+            }
+            catch (error) {
+                if (error instanceof NotFoundError) {
+                    return false;
+                }
+                throw error;
+            }
+        },
+        async metadata(path) {
+            ensureActive();
+            validatePath(path);
+            return mapGitHubContentToFileInfo(await readContent(requestClient, repository, path, "github.files.metadata"));
+        },
+        async getMetadata(path) {
+            return this.metadata(path);
+        },
+        async readBinary(path) {
+            ensureActive();
+            validatePath(path);
+            const blob = mapGitHubContentToBlob(await readContent(requestClient, repository, path, "github.files.readBinary"));
+            return decodeBlobContent(blob);
+        },
+        async readJson(path) {
+            ensureActive();
+            const text = await this.readText(path);
+            return JSON.parse(text);
+        },
+        async readText(path) {
+            ensureActive();
+            validatePath(path);
+            return new TextDecoder().decode(decodeBlobContent(mapGitHubContentToBlob(await readContent(requestClient, repository, path, "github.files.readText"))));
+        },
+        async stream(path) {
+            ensureActive();
+            validatePath(path);
+            const content = await this.readBinary(path);
+            return (async function* streamContent() {
+                yield content;
+            })();
+        }
+    });
+}
+function createGitHubIssuesCapability(repository, requestClient, ensureActive) {
+    return deepFreeze({
+        async get(number) {
+            ensureActive();
+            validatePositiveInteger(number, "Issue number must be a positive integer");
+            const response = await requestGitHub(requestClient, "github.issues.get", `/repos/${encodePathPart(repository.owner)}/${encodePathPart(repository.name)}/issues/${number}`);
+            return mapGitHubIssue(response);
+        },
+        async list(options) {
+            ensureActive();
+            return requestGitHubPage(requestClient, "github.issues.list", withPagination(`/repos/${encodePathPart(repository.owner)}/${encodePathPart(repository.name)}/issues`, options), mapGitHubIssue);
+        }
+    });
+}
+function createGitHubPullRequestsCapability(repository, requestClient, ensureActive) {
+    return deepFreeze({
+        async get(number) {
+            ensureActive();
+            validatePositiveInteger(number, "Pull request number must be a positive integer");
+            const response = await requestGitHub(requestClient, "github.pullRequests.get", `/repos/${encodePathPart(repository.owner)}/${encodePathPart(repository.name)}/pulls/${number}`);
+            return mapGitHubPullRequest(response, repository);
+        },
+        async list(options) {
+            ensureActive();
+            return requestGitHubPage(requestClient, "github.pullRequests.list", withPagination(`/repos/${encodePathPart(repository.owner)}/${encodePathPart(repository.name)}/pulls`, options), (pullRequest) => mapGitHubPullRequest(pullRequest, repository));
+        }
+    });
+}
+function createGitHubReleasesCapability(repository, requestClient, ensureActive) {
+    return deepFreeze({
+        async get(tagName) {
+            ensureActive();
+            validateNonEmpty(tagName, "Release tag name must be a non-empty string");
+            const response = await requestGitHub(requestClient, "github.releases.get", `/repos/${encodePathPart(repository.owner)}/${encodePathPart(repository.name)}/releases/tags/${encodePathPart(tagName)}`);
+            return mapGitHubRelease(response);
+        },
+        async list(options) {
+            ensureActive();
+            return requestGitHubPage(requestClient, "github.releases.list", withPagination(`/repos/${encodePathPart(repository.owner)}/${encodePathPart(repository.name)}/releases`, options), mapGitHubRelease);
+        }
+    });
+}
+function createGitHubSearchCapability(repository, requestClient, ensureActive) {
+    return deepFreeze({
+        async query(query) {
+            ensureActive();
+            validateNonEmpty(query.text, "Search query text must be a non-empty string");
+            const pathQualifier = query.path === undefined ? "" : ` path:${query.path}`;
+            const response = await requestGitHub(requestClient, "github.search.query", withPagination(`/search/code?q=${encodeURIComponent(`${query.text} repo:${repository.owner}/${repository.name}${pathQualifier}`)}`, query));
+            return createSearchPage(response);
+        },
+        async text(query, options) {
+            ensureActive();
+            validateNonEmpty(query, "Search query text must be a non-empty string");
+            return this.query({ text: query, ...(options ?? {}) });
+        }
+    });
+}
+async function requestGitHubPage(requestClient, operation, url, map) {
+    const response = await requestGitHubResponse(requestClient, operation, url);
+    if (response.data === undefined) {
+        throw new ProviderError("GitHub response did not include a response body", {
+            diagnostics: {
+                operation: { operation },
+                provider: { provider: GitHubProviderId, status: response.status }
+            },
+            retryability: "Maybe"
+        });
+    }
+    return createPage(response.data.map(map), response.headers);
+}
+function createSearchPage(response) {
+    return deepFreeze({
+        items: (response.items ?? []).map((item) => mapGitHubSearchItem(item)),
+        pageInfo: {
+            hasNextPage: false,
+            hasPreviousPage: false,
+            totalCount: response.total_count
+        }
+    });
+}
+async function rejectUnsupported(capability, repository) {
+    throw new CapabilityNotSupportedError("GitHub provider capability operation is not supported", {
+        diagnostics: {
+            operation: { capability, operation: `github.${capability}` },
+            provider: { provider: GitHubProviderId },
+            repository: formatRepositoryDiagnostics(repository)
+        },
+        retryability: "Never"
+    });
+}
+async function* rejectUnsupportedIterable(capability, repository) {
+    await rejectUnsupported(capability, repository);
+}
+function parseGitHubRepositoryUrl(value, hosts) {
+    try {
+        const url = new URL(value);
+        const host = normalizeHost(url.hostname);
+        if (!hosts.includes(host)) {
+            return undefined;
+        }
+        const parts = url.pathname
+            .replace(/\.git$/u, "")
+            .split("/")
+            .filter((part) => part.length > 0);
+        const offset = host === "api.github.com" && parts[0] === "repos" ? 1 : 0;
+        const owner = parts[offset];
+        const name = parts[offset + 1];
+        if (owner === undefined || name === undefined) {
+            return undefined;
+        }
+        return { host, name, owner, url: `https://${host}/${owner}/${name}` };
+    }
+    catch {
+        return undefined;
+    }
+}
+function resolveRepositoryLocation(repository, hosts) {
+    if ("url" in repository) {
+        const location = parseGitHubRepositoryUrl(repository.url, hosts);
+        if (location === undefined) {
+            throw new ValidationError("Repository locator is not a supported GitHub URL", {
+                diagnostics: {
+                    operation: { operation: "github.repository.resolve" },
+                    provider: { provider: GitHubProviderId },
+                    extra: { url: repository.url }
+                }
+            });
+        }
+        return location;
+    }
+    validateRepositoryIdentity(repository);
+    return {
+        host: hosts[0] ?? "github.com",
+        name: repository.name,
+        owner: repository.owner,
+        url: `https://${hosts[0] ?? "github.com"}/${repository.owner}/${repository.name}`
+    };
+}
+function toRepositoryIdentity(location) {
+    return deepFreeze({
+        name: location.name,
+        owner: location.owner,
+        provider: GitHubProviderId
+    });
+}
+function toRepositoryInfo(location) {
+    const identity = toRepositoryIdentity(location);
+    return deepFreeze({
+        fullName: `${identity.owner}/${identity.name}`,
+        identity,
+        metadata: { provider: GitHubProviderId, extra: { host: location.host } },
+        name: identity.name,
+        owner: { username: identity.owner },
+        url: location.url,
+        visibility: "unknown"
+    });
+}
+function toTransportRequest(request, context) {
+    const headers = {
+        accept: "application/vnd.github+json",
+        ...authorizationHeader(context.authentication),
+        ...request.headers
+    };
+    return deepFreeze({
+        body: request.body,
+        headers,
+        method: toTransportMethod(request.method),
+        metadata: {
+            provider: GitHubProviderId,
+            ...context.metadata
+        },
+        signal: request.signal,
+        target: request.url,
+        timeoutMs: request.timeoutMs
+    });
+}
+function fromTransportResponse(response) {
+    const data = getResponseData(response);
+    return deepFreeze({
+        data,
+        headers: response.headers,
+        status: response.status
+    });
+}
+function getResponseData(response) {
+    const record = response;
+    return record.body ?? record.data;
+}
+function toTransportMethod(method) {
+    if (method === undefined || method === "GET") {
+        return "read";
+    }
+    if (method === "DELETE") {
+        return "delete";
+    }
+    return "write";
+}
+function authorizationHeader(authentication) {
+    const credentials = authentication?.credentials;
+    if (credentials === undefined || credentials.kind === "anonymous" || !("token" in credentials)) {
+        return {};
+    }
+    return { authorization: `Bearer ${credentials.token}` };
+}
+function createGitHubHttpTransport() {
+    return deepFreeze({
+        async execute(request) {
+            const response = await executeGitHubHttpRequest(request);
+            return createTransportResponse(response);
+        }
+    });
+}
+async function executeGitHubHttpRequest(request) {
+    const requestUrl = toGitHubApiUrl(request.target);
+    const init = {
+        method: toHttpMethod(request.method)
+    };
+    const requestBody = toHttpRequestBody(request.body);
+    if (requestBody !== undefined) {
+        init.body = requestBody;
+    }
+    if (request.headers !== undefined) {
+        init.headers = request.headers;
+    }
+    if (request.signal !== undefined) {
+        init.signal = request.signal;
+    }
+    const response = await getFetchImplementation()(requestUrl, init);
+    const responseBody = await readHttpResponseBody(response);
+    const transportResponse = {
+        headers: Object.fromEntries(response.headers.entries()),
+        status: response.status
+    };
+    if (responseBody !== undefined) {
+        transportResponse.body = responseBody;
+    }
+    return transportResponse;
+}
+function getFetchImplementation() {
+    const fetchImplementation = globalThis["fetch"];
+    if (typeof fetchImplementation !== "function") {
+        throw new TransportError("GitHub provider requires a fetch-compatible runtime", {
+            diagnostics: {
+                operation: { operation: "github.transport.configure" },
+                provider: { provider: GitHubProviderId }
+            },
+            retryability: "Never"
+        });
+    }
+    return fetchImplementation.bind(globalThis);
+}
+function toGitHubApiUrl(target) {
+    if (/^https?:\/\//u.test(target)) {
+        return target;
+    }
+    return `https://api.github.com${target.startsWith("/") ? target : `/${target}`}`;
+}
+function toHttpMethod(method) {
+    switch (method) {
+        case "delete":
+            return "DELETE";
+        case "write":
+            return "POST";
+        case "read":
+        case "stream":
+            return "GET";
+    }
+}
+function toHttpRequestBody(body) {
+    if (body === undefined) {
+        return undefined;
+    }
+    if (typeof body === "string" || body instanceof Uint8Array) {
+        return body;
+    }
+    return JSON.stringify(body);
+}
+async function readHttpResponseBody(response) {
+    if (response.status === 204 || response.status === 205) {
+        return undefined;
+    }
+    const text = await response.text();
+    if (text.length === 0) {
+        return undefined;
+    }
+    const contentType = response.headers.get("content-type") ?? "";
+    if (contentType.includes("application/json")) {
+        return JSON.parse(text);
+    }
+    return text;
+}
+function createGitHubStatusError(status, operation, headers) {
+    if (status === 401) {
+        return new AuthenticationError("GitHub authentication failed", {
+            diagnostics: {
+                operation: { operation },
+                provider: { provider: GitHubProviderId, status }
+            },
+            retryability: "Never"
+        });
+    }
+    if (status === 403 && isRateLimitError({ headers, status })) {
+        return new RateLimitError("GitHub rate limit exceeded", {
+            diagnostics: {
+                operation: { operation },
+                provider: { provider: GitHubProviderId, status }
+            },
+            retryability: "Always"
+        });
+    }
+    if (status === 403) {
+        return new AuthorizationError("GitHub authorization failed", {
+            diagnostics: {
+                operation: { operation },
+                provider: { provider: GitHubProviderId, status }
+            },
+            retryability: "Never"
+        });
+    }
+    if (status === 404) {
+        return new NotFoundError("GitHub resource was not found", {
+            diagnostics: {
+                operation: { operation },
+                provider: { provider: GitHubProviderId, status }
+            },
+            retryability: "Never"
+        });
+    }
+    if (status === 409) {
+        return new ConflictError("GitHub reported a resource conflict", {
+            diagnostics: {
+                operation: { operation },
+                provider: { provider: GitHubProviderId, status }
+            },
+            retryability: "Maybe"
+        });
+    }
+    return new ProviderError("GitHub provider rejected the request", {
+        diagnostics: {
+            operation: { operation },
+            provider: { provider: GitHubProviderId, status }
+        },
+        retryability: retryabilityForStatus(status)
+    });
+}
+function createPage(items, headers) {
+    const link = headers?.link ?? headers?.Link;
+    return deepFreeze({
+        items,
+        pageInfo: parsePaginationInfo(link)
+    });
+}
+function parsePaginationInfo(link) {
+    if (link === undefined) {
+        return {
+            hasNextPage: false,
+            hasPreviousPage: false
+        };
+    }
+    const info = {
+        hasNextPage: link.includes('rel="next"'),
+        hasPreviousPage: link.includes('rel="prev"')
+    };
+    const next = extractPageCursor(link, "next");
+    const previous = extractPageCursor(link, "prev");
+    if (next !== undefined) {
+        info.endCursor = next;
+    }
+    if (previous !== undefined) {
+        info.startCursor = previous;
+    }
+    return info;
+}
+function extractPageCursor(link, relation) {
+    const match = new RegExp(`<[^>]*[?&]page=([^>&]+)[^>]*>;\\s*rel="${relation}"`, "u").exec(link);
+    return match?.[1];
+}
+function withPagination(url, options) {
+    const parameters = [];
+    if (options?.cursor !== undefined) {
+        parameters.push(`page=${encodeURIComponent(options.cursor)}`);
+    }
+    if (options?.limit !== undefined) {
+        parameters.push(`per_page=${encodeURIComponent(String(options.limit))}`);
+    }
+    if (parameters.length === 0) {
+        return url;
+    }
+    return `${url}${url.includes("?") ? "&" : "?"}${parameters.join("&")}`;
+}
+function decodeBlobContent(blob) {
+    if (blob.content instanceof Uint8Array) {
+        return blob.content;
+    }
+    if (blob.content === undefined) {
+        return new Uint8Array();
+    }
+    if (blob.encoding === "base64") {
+        return Buffer.from(blob.content.replace(/\s+/gu, ""), "base64");
+    }
+    return new TextEncoder().encode(blob.content);
+}
+function encodePathPart(value) {
+    return encodeURIComponent(value);
+}
+function encodeRepositoryPath(path) {
+    return path.split("/").map(encodePathPart).join("/");
+}
+async function runGitHubProviderOperation(operation, execute) {
+    try {
+        return await execute();
+    }
+    catch (error) {
+        throw mapGitHubError(error, operation);
+    }
+}
+function getErrorStatus(error) {
+    return getNumericProperty(error, "status") ?? getNumericProperty(error, "statusCode");
+}
+function getErrorCode(error) {
+    return getStringProperty(error, "code");
+}
+function getErrorRequestId(error) {
+    const headers = getHeaders(error);
+    return headers?.["x-github-request-id"] ?? headers?.["x-request-id"];
+}
+function isRateLimitError(error) {
+    const headers = getHeaders(error);
+    return headers?.["x-ratelimit-remaining"] === "0" || getErrorCode(error) === "rate_limit";
+}
+function getHeaders(error) {
+    if (error === null || typeof error !== "object" || !("headers" in error)) {
+        return undefined;
+    }
+    const headers = error.headers;
+    if (headers === null || typeof headers !== "object") {
+        return undefined;
+    }
+    const normalized = {};
+    for (const [key, value] of Object.entries(headers)) {
+        if (typeof value === "string") {
+            normalized[key.toLowerCase()] = value;
+        }
+    }
+    return normalized;
+}
+function getNumericProperty(error, key) {
+    if (error === null || typeof error !== "object" || !(key in error)) {
+        return undefined;
+    }
+    const value = error[key];
+    return typeof value === "number" ? value : undefined;
+}
+function getStringProperty(error, key) {
+    if (error === null || typeof error !== "object" || !(key in error)) {
+        return undefined;
+    }
+    const value = error[key];
+    return typeof value === "string" ? value : undefined;
+}
+function retryabilityForStatus(status) {
+    return status === 408 || status === 409 || status === 429 ? "Maybe" : "Never";
+}
+function normalizeHosts(hosts) {
+    const normalized = hosts.map(normalizeHost);
+    if (normalized.length === 0) {
+        throw new ValidationError("GitHub provider requires at least one host", {
+            diagnostics: {
+                operation: { operation: "github.provider.configure" },
+                provider: { provider: GitHubProviderId }
+            }
+        });
+    }
+    return [...new Set(normalized)];
+}
+function normalizeHost(host) {
+    validateNonEmpty(host, "GitHub host must be a non-empty string");
+    return host.toLowerCase().replace(/^www\./u, "");
+}
+function validateRepositoryIdentity(identity) {
+    validateNonEmpty(identity.provider, "Repository provider must be a non-empty string");
+    validateNonEmpty(identity.owner, "Repository owner must be a non-empty string");
+    validateNonEmpty(identity.name, "Repository name must be a non-empty string");
+    if (identity.provider !== GitHubProviderId) {
+        throw new ValidationError("Repository identity does not belong to the GitHub provider", {
+            diagnostics: {
+                operation: { operation: "github.repository.validate" },
+                provider: { provider: GitHubProviderId },
+                repository: formatRepositoryDiagnostics(identity)
+            }
+        });
+    }
+}
+function validatePath(path) {
+    validateNonEmpty(path, "Repository path must be a non-empty string");
+}
+function validateOptionalPath(path) {
+    if (path !== undefined) {
+        validatePath(path);
+    }
+}
+function validatePositiveInteger(value, message) {
+    if (!Number.isInteger(value) || value <= 0) {
+        throw new ValidationError(message, {
+            diagnostics: {
+                operation: { operation: "github.provider.validate" },
+                provider: { provider: GitHubProviderId }
+            }
+        });
+    }
+}
+function validateNonEmpty(value, message) {
+    if (value.trim() === "") {
+        throw new ValidationError(message, {
+            diagnostics: {
+                operation: { operation: "github.provider.validate" },
+                provider: { provider: GitHubProviderId }
+            }
+        });
+    }
+}
+function formatRepositoryDiagnostics(identity) {
+    return {
+        provider: identity.provider,
+        repository: `${identity.owner}/${identity.name}`
+    };
+}