@git.zone/cli 6.9.0 → 6.10.0

package/dist_ts/mod_release/helpers.giteaassets.js

@@ -0,0 +1,661 @@
+import * as plugins from "./mod.plugins.js";
+const maximumManifestBytes = 4 * 1024 * 1024;
+const maximumMetadataBytes = 8 * 1024 * 1024;
+const maximumAssetBytes = 32 * 1024 * 1024 * 1024;
+const maximumAssets = 1024;
+const canonicalName = /^[A-Za-z0-9][A-Za-z0-9._-]{0,199}$/;
+const sha256Pattern = /^[a-f0-9]{64}$/;
+export class GiteaAssetConflictError extends Error {
+    constructor(message) {
+        super(message);
+        this.name = "GiteaAssetConflictError";
+    }
+}
+class GiteaAssetHttpError extends Error {
+    constructor(method, status) {
+        super(`Gitea asset ${method} returned HTTP ${status}; inspect the retained release before another mutation.`);
+    }
+}
+const record = (value) => {
+    if (!value || typeof value !== "object" || Array.isArray(value)) {
+        throw new Error("Invalid Gitea asset object.");
+    }
+    return value;
+};
+const exactKeys = (value, keys) => {
+    if (Object.keys(value).sort().join("\0") !== [...keys].sort().join("\0")) {
+        throw new Error("Unexpected Gitea asset manifest fields.");
+    }
+};
+const positiveId = (value) => {
+    if (!Number.isSafeInteger(value) || value <= 0) {
+        throw new Error("Invalid Gitea response identifier.");
+    }
+    return value;
+};
+const assertName = (value) => {
+    if (typeof value !== "string" || !canonicalName.test(value)) {
+        throw new Error("Gitea asset names must be canonical single path components.");
+    }
+    return value;
+};
+const assertTag = (value) => {
+    if (!canonicalName.test(value) ||
+        value.endsWith(".") ||
+        value.endsWith(".lock") ||
+        value.includes("..")) {
+        throw new Error("Gitea asset publication requires a canonical release tag.");
+    }
+};
+const assertSizeAndHash = (value) => {
+    if (!Number.isSafeInteger(value.size) ||
+        value.size < 0 ||
+        value.size > maximumAssetBytes ||
+        typeof value.sha256 !== "string" ||
+        !sha256Pattern.test(value.sha256)) {
+        throw new Error("Invalid Gitea asset size or SHA256.");
+    }
+};
+export const normalizeGiteaAssetDestination = (value) => {
+    const candidate = record(value);
+    exactKeys(candidate, ["apiOrigin", "owner", "repository"]);
+    let url;
+    try {
+        url = new URL(candidate.apiOrigin);
+    }
+    catch {
+        throw new Error("Invalid Gitea API origin.");
+    }
+    if (url.protocol !== "https:" ||
+        url.username ||
+        url.password ||
+        url.search ||
+        url.hash ||
+        url.pathname !== "/" ||
+        ![url.origin, `${url.origin}/`].includes(candidate.apiOrigin)) {
+        throw new Error("Gitea API origin must be credential-free canonical HTTPS.");
+    }
+    return {
+        apiOrigin: url.origin,
+        owner: assertName(candidate.owner),
+        repository: assertName(candidate.repository),
+    };
+};
+export const giteaAssetFileName = (name) => `asset.${plugins.crypto.createHash("sha256").update(assertName(name)).digest("hex")}.bin`;
+export const giteaAssetPublicUrl = (destination, tag, name) => {
+    const normalized = normalizeGiteaAssetDestination(destination);
+    assertTag(tag);
+    return `${normalized.apiOrigin}/${normalized.owner}/${normalized.repository}/releases/download/${encodeURIComponent(tag)}/${assertName(name)}`;
+};
+const assertRelativeAssetPath = (value) => {
+    if (typeof value !== "string" ||
+        value.length > 4096 ||
+        value
+            .split("/")
+            .some((part) => !canonicalName.test(part) ||
+            /^(?:node_modules|coverage|secrets?|credentials?|runtime|data|tmp|temp|id_rsa|id_ed25519)(?:\..*)?$/i.test(part) ||
+            /\.(?:pem|key|p12|pfx)$/i.test(part))) {
+        throw new Error("Asset inputs require canonical repository paths outside credential/runtime directories.");
+    }
+    return value;
+};
+/** Reject symlinks in every component, including the caller-provided root. */
+const assertRegularPath = async (absolutePath, directory = false) => {
+    const resolved = plugins.path.resolve(absolutePath);
+    const parsed = plugins.path.parse(resolved);
+    let current = parsed.root;
+    const parts = resolved
+        .slice(parsed.root.length)
+        .split(plugins.path.sep)
+        .filter(Boolean);
+    for (let index = 0; index < parts.length; index++) {
+        current = plugins.path.join(current, parts[index]);
+        const stat = await plugins.fs.lstat(current);
+        const expectDirectory = index < parts.length - 1 || directory;
+        if (stat.isSymbolicLink() ||
+            (expectDirectory ? !stat.isDirectory() : !stat.isFile())) {
+            throw new Error("Gitea asset paths must use regular files and directories without symlinks.");
+        }
+    }
+};
+const openRegularFile = async (path) => {
+    await assertRegularPath(path);
+    const handle = await plugins.fs.open(path, plugins.fsConstants.O_RDONLY | plugins.fsConstants.O_NOFOLLOW);
+    try {
+        if (!(await handle.stat()).isFile())
+            throw new Error("Gitea asset input is not a regular file.");
+        return handle;
+    }
+    catch (error) {
+        await handle.close();
+        throw error;
+    }
+};
+const readBoundedFile = async (path, maximum) => {
+    const handle = await openRegularFile(path);
+    try {
+        if ((await handle.stat()).size > maximum)
+            throw new Error("Gitea asset metadata exceeds its size limit.");
+        const chunks = [];
+        let size = 0;
+        for await (const chunk of handle.createReadStream({
+            autoClose: false,
+            highWaterMark: 64 * 1024,
+        })) {
+            size += chunk.length;
+            if (size > maximum)
+                throw new Error("Gitea asset metadata exceeds its size limit.");
+            chunks.push(chunk);
+        }
+        return Buffer.concat(chunks, size);
+    }
+    finally {
+        await handle.close();
+    }
+};
+const verifyHandle = async (handle, asset) => {
+    const before = await handle.stat();
+    if (before.size !== asset.size)
+        throw new Error("Stored Gitea asset size conflicts with its frozen identity.");
+    const hash = plugins.crypto.createHash("sha256");
+    let size = 0;
+    for await (const chunk of handle.createReadStream({
+        autoClose: false,
+        start: 0,
+        highWaterMark: 64 * 1024,
+    })) {
+        size += chunk.length;
+        if (size > asset.size)
+            throw new Error("Stored Gitea asset exceeds its frozen size.");
+        hash.update(chunk);
+    }
+    const after = await handle.stat();
+    if (size !== asset.size ||
+        hash.digest("hex") !== asset.sha256 ||
+        before.mtimeMs !== after.mtimeMs ||
+        before.ctimeMs !== after.ctimeMs) {
+        throw new Error("Stored Gitea asset bytes conflict with their frozen identity.");
+    }
+};
+export function assertGiteaFrozenAssets(assets, destination, tag) {
+    if (!Array.isArray(assets) ||
+        assets.length === 0 ||
+        assets.length > maximumAssets)
+        throw new Error("Invalid Gitea asset set.");
+    const names = new Set();
+    for (const entry of assets) {
+        const asset = record(entry);
+        exactKeys(asset, ["name", "size", "sha256", "fileName", "publicUrl"]);
+        const name = assertName(asset.name);
+        assertSizeAndHash(asset);
+        if (names.has(name) || asset.fileName !== giteaAssetFileName(name))
+            throw new Error("Duplicate or invalid stored Gitea asset identity.");
+        names.add(name);
+        let url;
+        try {
+            url = new URL(asset.publicUrl);
+        }
+        catch {
+            throw new Error("Invalid frozen Gitea asset URL.");
+        }
+        if (url.protocol !== "https:" ||
+            url.username ||
+            url.password ||
+            url.search ||
+            url.hash ||
+            url.href !== asset.publicUrl ||
+            (destination &&
+                tag &&
+                asset.publicUrl !== giteaAssetPublicUrl(destination, tag, name))) {
+            throw new Error("Frozen Gitea asset URL conflicts with its destination.");
+        }
+    }
+}
+export const validateGiteaAssets = async (artifactDirectory, assets) => {
+    assertGiteaFrozenAssets(assets);
+    await assertRegularPath(artifactDirectory, true);
+    for (const asset of assets) {
+        const handle = await openRegularFile(plugins.path.join(artifactDirectory, asset.fileName));
+        try {
+            await verifyHandle(handle, asset);
+        }
+        finally {
+            await handle.close();
+        }
+    }
+};
+export const prepareGiteaAssets = async (options) => {
+    const destination = normalizeGiteaAssetDestination(options.destination);
+    assertTag(options.tag);
+    if (!/^\d+\.\d+\.\d+(?:-[A-Za-z0-9.-]+)?(?:\+[A-Za-z0-9.-]+)?$/.test(options.version))
+        throw new Error("Invalid Gitea asset manifest release version.");
+    await assertRegularPath(options.repositoryRoot, true);
+    const manifestPath = plugins.path.join(options.repositoryRoot, assertRelativeAssetPath(options.manifestPath));
+    let manifest;
+    try {
+        manifest = record(JSON.parse((await readBoundedFile(manifestPath, maximumManifestBytes)).toString("utf8")));
+    }
+    catch {
+        throw new Error("Unable to read a bounded regular Gitea asset manifest.");
+    }
+    exactKeys(manifest, ["schemaVersion", "version", "assets"]);
+    if (manifest.schemaVersion !== 1 ||
+        manifest.version !== options.version ||
+        !Array.isArray(manifest.assets) ||
+        manifest.assets.length === 0 ||
+        manifest.assets.length > maximumAssets)
+        throw new Error("Gitea asset manifest must match the exact release version and schema.");
+    const paths = new Set();
+    const assets = manifest.assets.map((entry) => {
+        const input = record(entry);
+        exactKeys(input, ["name", "path", "size", "sha256"]);
+        const path = assertRelativeAssetPath(input.path);
+        if (paths.has(path))
+            throw new Error("Gitea asset input paths must be unique.");
+        paths.add(path);
+        const name = assertName(input.name);
+        assertSizeAndHash(input);
+        return {
+            name,
+            size: input.size,
+            sha256: input.sha256,
+            fileName: giteaAssetFileName(name),
+            publicUrl: giteaAssetPublicUrl(destination, options.tag, name),
+        };
+    });
+    assertGiteaFrozenAssets(assets, destination, options.tag);
+    // The journal owner creates this directory; never follow/create an unexpected root here.
+    await assertRegularPath(options.artifactDirectory, true);
+    for (let index = 0; index < assets.length; index++) {
+        const asset = assets[index];
+        const inputPath = plugins.path.join(options.repositoryRoot, [...paths][index]);
+        const input = await openRegularFile(inputPath);
+        try {
+            await verifyHandle(input, asset);
+            const outputPath = plugins.path.join(options.artifactDirectory, asset.fileName);
+            const output = await plugins.fs.open(outputPath, "wx", 0o600);
+            try {
+                let position = 0;
+                for await (const chunk of input.createReadStream({
+                    autoClose: false,
+                    start: 0,
+                    highWaterMark: 64 * 1024,
+                })) {
+                    if (position + chunk.length > asset.size)
+                        throw new Error("Gitea asset changed during freezing.");
+                    let written = 0;
+                    while (written < chunk.length) {
+                        const result = await output.write(chunk, written, chunk.length - written, position + written);
+                        if (!result.bytesWritten)
+                            throw new Error("Unable to freeze complete Gitea asset bytes.");
+                        written += result.bytesWritten;
+                    }
+                    position += chunk.length;
+                }
+                await output.sync();
+            }
+            finally {
+                await output.close();
+            }
+            // Includes detecting same-size mutation between the validation and copy passes.
+            await validateGiteaAssets(options.artifactDirectory, [asset]);
+        }
+        finally {
+            await input.close();
+        }
+    }
+    return assets;
+};
+/** No method retries a remote mutation. The release journal owns attempt admission. */
+export class GiteaAssetsClient {
+    destination;
+    tag;
+    commit;
+    #token;
+    fetchImplementation;
+    timeoutMs;
+    repositoryApiPath;
+    constructor(options) {
+        this.destination = normalizeGiteaAssetDestination(options.destination);
+        assertTag(options.tag);
+        if (!/^(?:[a-f0-9]{40}|[a-f0-9]{64})$/.test(options.commit))
+            throw new Error("Gitea assets require the exact release commit.");
+        if (typeof options.token !== "string" ||
+            !options.token ||
+            /[\s\x00-\x1f\x7f]/.test(options.token))
+            throw new Error("A valid configured Gitea token is required.");
+        this.tag = options.tag;
+        this.commit = options.commit;
+        this.#token = options.token;
+        this.fetchImplementation = options.fetchImplementation ?? fetch;
+        this.timeoutMs = options.timeoutMs ?? 15 * 60_000;
+        if (!Number.isSafeInteger(this.timeoutMs) ||
+            this.timeoutMs <= 0 ||
+            this.timeoutMs > 60 * 60_000)
+            throw new Error("Invalid Gitea asset request timeout.");
+        this.repositoryApiPath = `/repos/${this.destination.owner}/${this.destination.repository}`;
+    }
+    async requestJson(path, authenticated, method = "GET", body, headers, allow404 = false) {
+        const controller = new AbortController();
+        const timeout = setTimeout(() => controller.abort(), this.timeoutMs);
+        let response;
+        try {
+            const init = {
+                method,
+                redirect: "manual",
+                signal: controller.signal,
+                headers: {
+                    Accept: "application/json",
+                    ...headers,
+                    ...(authenticated ? { Authorization: `token ${this.#token}` } : {}),
+                },
+                ...(body === undefined ? {} : { body, duplex: "half" }),
+            };
+            response = await this.fetchImplementation(`${this.destination.apiOrigin}/api/v1${path}`, init);
+            if (allow404 && response.status === 404)
+                return null;
+            if (response.status !== (method === "POST" ? 201 : 200)) {
+                throw new GiteaAssetHttpError(method, response.status);
+            }
+            const bytes = await this.readResponse(response, maximumMetadataBytes);
+            return JSON.parse(bytes.toString("utf8"));
+        }
+        catch (error) {
+            // Never include response text, fetch errors, URLs or causes that can expose the token.
+            if (error instanceof GiteaAssetHttpError)
+                throw error;
+            throw new Error(`Gitea asset ${method} result is inconclusive; inspect the retained release before another mutation.`);
+        }
+        finally {
+            controller.abort();
+            clearTimeout(timeout);
+            if (response?.body && !response.body.locked)
+                await response.body.cancel().catch(() => undefined);
+        }
+    }
+    async readResponse(response, maximum) {
+        if (!response.body)
+            throw new Error("Missing Gitea response body.");
+        const declared = response.headers.get("content-length");
+        if (declared !== null &&
+            (!/^\d+$/.test(declared) || Number(declared) > maximum))
+            throw new Error("Oversized Gitea response.");
+        const reader = response.body.getReader();
+        const chunks = [];
+        let size = 0;
+        try {
+            while (true) {
+                const result = await reader.read();
+                if (result.done)
+                    break;
+                size += result.value.byteLength;
+                if (size > maximum)
+                    throw new Error("Oversized Gitea response.");
+                chunks.push(Buffer.from(result.value));
+            }
+        }
+        finally {
+            await reader.cancel().catch(() => undefined);
+            reader.releaseLock();
+        }
+        return Buffer.concat(chunks, size);
+    }
+    async admitRepository(authenticated) {
+        const repo = record(await this.requestJson(this.repositoryApiPath, authenticated));
+        if (repo.full_name !==
+            `${this.destination.owner}/${this.destination.repository}` ||
+            repo.private !== false ||
+            repo.internal !== false ||
+            repo.archived !== false ||
+            repo.has_releases !== true ||
+            repo.html_url !==
+                `${this.destination.apiOrigin}/${this.destination.owner}/${this.destination.repository}`) {
+            throw new GiteaAssetConflictError("Gitea asset destination must be the exact public writable repository with releases enabled.");
+        }
+        positiveId(repo.id);
+        return repo;
+    }
+    async preflight() {
+        const anonymous = await this.admitRepository(false);
+        const authenticated = await this.admitRepository(true);
+        if (anonymous.id !== authenticated.id)
+            throw new GiteaAssetConflictError("Authenticated and public Gitea repository identities differ.");
+        // Gitea exposes push for Code only. Repository admins are guaranteed access
+        // to the Releases unit; aggregate collaborator/team write is insufficient.
+        if (record(authenticated.permissions).admin !== true)
+            throw new Error("Gitea asset publication requires an existing repository-admin publisher and a write:repository token; code-push permission alone cannot prove Releases-unit access.");
+        const token = record(await this.requestJson("/token", true));
+        if (!Array.isArray(token.scopes) ||
+            !token.scopes.some((scope) => scope === "all" || scope === "write:repository"))
+            throw new Error("Gitea token lacks write:repository scope.");
+        const settings = record(await this.requestJson("/settings/attachment", false));
+        if (settings.enabled !== true ||
+            !Number.isSafeInteger(settings.max_size) ||
+            settings.max_size <= 0 ||
+            !Number.isSafeInteger(settings.max_size * 1024 * 1024))
+            throw new Error("Gitea attachments are disabled or settings cannot be verified.");
+        return {
+            repositoryId: anonymous.id,
+            generalAttachmentMaximumBytes: settings.max_size * 1024 * 1024,
+        };
+    }
+    async admitTag() {
+        await this.admitRepository(false);
+        const tag = record(await this.requestJson(`${this.repositoryApiPath}/tags/${encodeURIComponent(this.tag)}`, false));
+        if (tag.name !== this.tag || record(tag.commit).sha !== this.commit)
+            throw new GiteaAssetConflictError("Gitea release tag does not identify the frozen release commit.");
+    }
+    release(value) {
+        const release = record(value);
+        const id = positiveId(release.id);
+        const publicUrl = `${this.destination.apiOrigin}/${this.destination.owner}/${this.destination.repository}/releases/tag/${encodeURIComponent(this.tag)}`;
+        if (release.tag_name !== this.tag ||
+            release.draft !== false ||
+            release.prerelease !== false ||
+            release.html_url !== publicUrl ||
+            release.url !==
+                `${this.destination.apiOrigin}/api/v1${this.repositoryApiPath}/releases/${id}`)
+            throw new GiteaAssetConflictError("Gitea release identity conflicts with the exact public release.");
+        return { id, tag: this.tag, publicUrl };
+    }
+    async inspectRelease() {
+        await this.admitTag();
+        const path = `${this.repositoryApiPath}/releases/tags/${encodeURIComponent(this.tag)}`;
+        const authenticated = await this.requestJson(path, true, "GET", undefined, undefined, true);
+        const anonymous = await this.requestJson(path, false, "GET", undefined, undefined, true);
+        if (authenticated === null && anonymous === null)
+            return null;
+        if (authenticated === null || anonymous === null)
+            throw new Error("Gitea release visibility is inconclusive; public and authenticated lookups differ.");
+        const found = this.release(authenticated);
+        if (this.release(anonymous).id !== found.id)
+            throw new GiteaAssetConflictError("Gitea release is not anonymously available with the same identity.");
+        return found;
+    }
+    async createRelease() {
+        await this.admitTag();
+        const result = this.release(await this.requestJson(`${this.repositoryApiPath}/releases`, true, "POST", JSON.stringify({
+            tag_name: this.tag,
+            target_commitish: this.commit,
+            name: this.tag,
+            draft: false,
+            prerelease: false,
+        }), { "Content-Type": "application/json" }));
+        const verified = await this.inspectRelease();
+        if (!verified)
+            throw new Error("Created Gitea release visibility is inconclusive; inspect before another mutation.");
+        if (verified.id !== result.id)
+            throw new GiteaAssetConflictError("Created Gitea release identity cannot be verified.");
+        return result;
+    }
+    async verifyPublicBytes(asset) {
+        const controller = new AbortController();
+        const timeout = setTimeout(() => controller.abort(), this.timeoutMs);
+        let response;
+        try {
+            let url = new URL(asset.publicUrl);
+            for (let redirects = 0;; redirects++) {
+                if (url.protocol !== "https:" ||
+                    url.username ||
+                    url.password ||
+                    url.hash)
+                    throw new GiteaAssetConflictError("Unsafe anonymous asset redirect.");
+                response = await this.fetchImplementation(url.href, {
+                    redirect: "manual",
+                    signal: controller.signal,
+                    headers: { "Accept-Encoding": "identity" },
+                });
+                if (![301, 302, 303, 307, 308].includes(response.status))
+                    break;
+                if (redirects >= 5 || !response.headers.get("location"))
+                    throw new GiteaAssetConflictError("Invalid anonymous asset redirect.");
+                const next = new URL(response.headers.get("location"), url);
+                await response.body?.cancel();
+                url = next;
+            }
+            if (response.status !== 200 ||
+                !response.body ||
+                (response.headers.get("content-encoding") ?? "identity") !== "identity")
+                throw new Error("Asset is not anonymously downloadable.");
+            const length = response.headers.get("content-length");
+            if (length !== null &&
+                (!/^\d+$/.test(length) || Number(length) !== asset.size))
+                throw new GiteaAssetConflictError("Anonymous asset size mismatch.");
+            const hash = plugins.crypto.createHash("sha256");
+            let size = 0;
+            const reader = response.body.getReader();
+            try {
+                while (true) {
+                    const next = await reader.read();
+                    if (next.done)
+                        break;
+                    size += next.value.byteLength;
+                    if (size > asset.size)
+                        throw new GiteaAssetConflictError("Anonymous asset exceeds its frozen size.");
+                    hash.update(next.value);
+                }
+            }
+            finally {
+                await reader.cancel().catch(() => undefined);
+                reader.releaseLock();
+            }
+            if (size !== asset.size || hash.digest("hex") !== asset.sha256)
+                throw new GiteaAssetConflictError("Anonymous asset bytes mismatch.");
+        }
+        catch (error) {
+            if (error instanceof GiteaAssetConflictError)
+                throw error;
+            throw new Error("Gitea public asset verification is inconclusive; inspect availability before publication.");
+        }
+        finally {
+            controller.abort();
+            clearTimeout(timeout);
+            if (response?.body && !response.body.locked)
+                await response.body.cancel().catch(() => undefined);
+        }
+    }
+    attachment(value, asset) {
+        const attachment = record(value);
+        const id = positiveId(attachment.id);
+        if (attachment.name !== asset.name ||
+            attachment.size !== asset.size ||
+            attachment.browser_download_url !== asset.publicUrl)
+            throw new GiteaAssetConflictError("Gitea attachment metadata conflicts with the frozen asset.");
+        return id;
+    }
+    async inspectAssetsWithIds(releaseId, expected) {
+        positiveId(releaseId);
+        assertGiteaFrozenAssets(expected, this.destination, this.tag);
+        if ((await this.inspectRelease())?.id !== releaseId)
+            throw new GiteaAssetConflictError("Gitea release identifier changed.");
+        const values = await this.requestJson(`${this.repositoryApiPath}/releases/${releaseId}/assets`, false);
+        if (!Array.isArray(values) || values.length > maximumAssets)
+            throw new Error("Invalid Gitea attachment list.");
+        const present = [];
+        const seenNames = new Set();
+        const seenIds = new Set();
+        const attachmentIds = new Map();
+        for (const value of values) {
+            const name = record(value).name;
+            const asset = expected.find((candidate) => candidate.name === name);
+            if (!asset || seenNames.has(asset.name))
+                throw new GiteaAssetConflictError("Unexpected or duplicate Gitea release attachment.");
+            const id = this.attachment(value, asset);
+            if (seenIds.has(id))
+                throw new GiteaAssetConflictError("Duplicate Gitea release attachment identifier.");
+            seenNames.add(asset.name);
+            seenIds.add(id);
+            attachmentIds.set(asset.name, id);
+            await this.verifyPublicBytes(asset);
+            present.push(asset);
+        }
+        return {
+            inspection: {
+                present,
+                missing: expected.filter((asset) => !seenNames.has(asset.name)),
+            },
+            attachmentIds,
+        };
+    }
+    async inspectAssets(releaseId, expected) {
+        return (await this.inspectAssetsWithIds(releaseId, expected)).inspection;
+    }
+    async uploadAsset(releaseId, asset, artifactDirectory) {
+        positiveId(releaseId);
+        assertGiteaFrozenAssets([asset], this.destination, this.tag);
+        const handle = await openRegularFile(plugins.path.join(artifactDirectory, asset.fileName));
+        try {
+            await verifyHandle(handle, asset);
+            if ((await this.inspectRelease())?.id !== releaseId)
+                throw new GiteaAssetConflictError("Gitea release identifier changed before upload.");
+            const listed = await this.requestJson(`${this.repositoryApiPath}/releases/${releaseId}/assets`, false);
+            if (!Array.isArray(listed))
+                throw new Error("Invalid Gitea attachment list.");
+            if (listed.some((entry) => record(entry).name === asset.name))
+                throw new GiteaAssetConflictError("Gitea upload requires an absent attachment name; inspect the retained release.");
+            const stream = handle.createReadStream({
+                autoClose: false,
+                start: 0,
+                highWaterMark: 64 * 1024,
+            });
+            try {
+                const result = await this.requestJson(`${this.repositoryApiPath}/releases/${releaseId}/assets?name=${encodeURIComponent(asset.name)}`, true, "POST", stream, {
+                    "Content-Type": "application/octet-stream",
+                    "Content-Length": String(asset.size),
+                });
+                this.attachment(result, asset);
+            }
+            finally {
+                stream.destroy();
+            }
+            await this.verifyPublicBytes(asset);
+        }
+        finally {
+            await handle.close();
+        }
+    }
+    async verifyComplete(releaseId, expected) {
+        const { inspection, attachmentIds } = await this.inspectAssetsWithIds(releaseId, expected);
+        if (inspection.missing.length !== 0)
+            throw new Error("Gitea attachment set is incomplete; npm publication is blocked.");
+        // Recheck release/tag identity after potentially long full downloads.
+        if ((await this.inspectRelease())?.id !== releaseId)
+            throw new GiteaAssetConflictError("Gitea release changed during verification.");
+        const finalSet = await this.requestJson(`${this.repositoryApiPath}/releases/${releaseId}/assets`, false);
+        if (!Array.isArray(finalSet) || finalSet.length !== expected.length)
+            throw new GiteaAssetConflictError("Gitea attachment set changed during verification.");
+        const names = new Set();
+        const ids = new Set();
+        for (const value of finalSet) {
+            const asset = expected.find((entry) => entry.name === record(value).name);
+            if (!asset || names.has(asset.name))
+                throw new GiteaAssetConflictError("Gitea attachment set changed during verification.");
+            const id = this.attachment(value, asset);
+            if (ids.has(id) || attachmentIds.get(asset.name) !== id)
+                throw new GiteaAssetConflictError("Gitea attachment set changed during verification.");
+            names.add(asset.name);
+            ids.add(id);
+        }
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"helpers.giteaassets.js","sourceRoot":"","sources":["../../../ts/mod_release/helpers.giteaassets.ts"],"names":[],"mappings":"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"}