target-supabase-sdk 0.2.12 → 0.2.14

package/src/shared/log/spool/collector.ts

@@ -0,0 +1,330 @@
+import { access, constants, readdir, readFile, rename, stat, unlink } from "node:fs/promises";
+import { join } from "node:path";
+import { isLogEntry } from "../core/log-batch";
+import { computeLogBatchIdempotencyKey } from "../upload/batch-id";
+import { buildLogListDraft, postLogBatch } from "../upload/flush";
+import { spoolLogger } from "../upload/logger";
+import { type DEFAULT_LOG_SPOOL_CONFIG, resolveLogSpoolConfig } from "./config";
+import { parseLogSpoolBatchFilename } from "./file";
+import type { LogSpoolBatchFile, LogSpoolProcessRole } from "./interface";
+import { logSpoolProcessDir, resolveLogSpoolRoot } from "./paths";
+import { resolveAllLogSpoolProcessRoles } from "./process-roles";
+
+const UPLOAD_LANE = "slow";
+
+/** Per serviceId — guard collect-log tick runs GC at most once per `gc.intervalMs`. */
+const lastGcAtMsByServiceId = new Map<string, number>();
+
+export interface RunCollectLogTickInput {
+    serviceId: string;
+    serviceValue: string;
+    spoolRoot?: string;
+    config?: Partial<typeof DEFAULT_LOG_SPOOL_CONFIG>;
+    nowMs?: number;
+}
+
+export interface RunCollectLogTickResult {
+    uploaded: number;
+    skipped: number;
+    failed: number;
+    gcTmpRemoved: number;
+    gcSyncedRemoved: number;
+}
+
+async function pathExists(filePath: string): Promise<boolean> {
+    try {
+        await access(filePath, constants.F_OK);
+        return true;
+    } catch {
+        return false;
+    }
+}
+
+async function readBatchTmpFile(tmpPath: string): Promise<LogSpoolBatchFile | null> {
+    try {
+        const raw = await readFile(tmpPath, "utf8");
+        const parsed = JSON.parse(raw) as LogSpoolBatchFile;
+        if (!Array.isArray(parsed.entries) || parsed.entries.length === 0) {
+            return null;
+        }
+        const entries = parsed.entries.filter(isLogEntry);
+        if (entries.length === 0) {
+            return null;
+        }
+        return { entries, meta: parsed.meta };
+    } catch {
+        return null;
+    }
+}
+
+function processMetaKey(serviceId: string, processRole: LogSpoolProcessRole): string {
+    return `${serviceId}:${processRole}`;
+}
+
+async function uploadTmpBatch(input: {
+    serviceId: string;
+    serviceValue: string;
+    processRole: LogSpoolProcessRole;
+    tmpPath: string;
+    fileName: string;
+    spoolRoot: string;
+    postTimeoutMs: number;
+}): Promise<"uploaded" | "skipped" | "failed"> {
+    const parsed = parseLogSpoolBatchFilename(input.fileName);
+    if (parsed == null) {
+        spoolLogger.warn("collect-log skipped — invalid tmp filename", { fileName: input.fileName });
+        return "failed";
+    }
+
+    const jsonFileName = input.fileName.replace(/\.tmp$/, ".json");
+    const jsonPath = join(logSpoolProcessDir(input.spoolRoot, input.serviceId, input.processRole), jsonFileName);
+
+    if (await pathExists(jsonPath)) {
+        try {
+            await unlink(input.tmpPath);
+            spoolLogger.info("collect-log removed orphan tmp (json exists)", {
+                tmpPath: input.tmpPath,
+                jsonPath,
+            });
+        } catch {
+            // best-effort
+        }
+        return "skipped";
+    }
+
+    const batch = await readBatchTmpFile(input.tmpPath);
+    if (batch == null) {
+        spoolLogger.warn("collect-log skipped — tmp failed validation", {
+            tmpPath: input.tmpPath,
+            fileName: input.fileName,
+        });
+        try {
+            await unlink(input.tmpPath);
+            spoolLogger.info("collect-log removed invalid tmp", { tmpPath: input.tmpPath });
+        } catch {
+            // best-effort
+        }
+        return "failed";
+    }
+
+    const processKey = processMetaKey(input.serviceId, input.processRole);
+    // TODO: `lane` is legacy transport metadata — scheduled for removal; fixed to "slow" for downstream decode compatibility.
+    const idempotencyKey = computeLogBatchIdempotencyKey({
+        service: input.serviceValue,
+        process: processKey,
+        lane: UPLOAD_LANE,
+        entries: batch.entries,
+    });
+
+    const draft = buildLogListDraft({
+        service: input.serviceValue,
+        process: processKey,
+        lane: UPLOAD_LANE,
+        idempotencyKey,
+        entries: batch.entries,
+    });
+
+    try {
+        await postLogBatch(draft, input.postTimeoutMs);
+    } catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        spoolLogger.error("collect-log upload failed", {
+            fileName: input.fileName,
+            processRole: input.processRole,
+            error: message,
+        });
+        return "failed";
+    }
+
+    try {
+        await rename(input.tmpPath, jsonPath);
+    } catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        spoolLogger.error("collect-log rename tmp→json failed after upload", {
+            tmpPath: input.tmpPath,
+            jsonPath,
+            error: message,
+        });
+        return "failed";
+    }
+
+    spoolLogger.info("collect-log uploaded batch", {
+        processRole: input.processRole,
+        fileName: jsonFileName,
+        entryCount: batch.entries.length,
+        idempotencyKey,
+    });
+
+    return "uploaded";
+}
+
+async function gcTmpFiles(input: {
+    spoolRoot: string;
+    serviceId: string;
+    processRole: LogSpoolProcessRole;
+    tmpRetentionMs: number;
+    nowMs: number;
+}): Promise<number> {
+    const processDir = logSpoolProcessDir(input.spoolRoot, input.serviceId, input.processRole);
+    let removed = 0;
+
+    try {
+        const names = await readdir(processDir);
+        for (const name of names) {
+            if (!name.endsWith(".tmp")) {
+                continue;
+            }
+            const parsed = parseLogSpoolBatchFilename(name);
+            if (parsed == null) {
+                continue;
+            }
+            if (input.nowMs - parsed.timestampMs <= input.tmpRetentionMs) {
+                continue;
+            }
+            try {
+                await unlink(join(processDir, name));
+                removed += 1;
+                spoolLogger.info("collect-log gc removed stale tmp", {
+                    fileName: name,
+                    processRole: input.processRole,
+                });
+            } catch {
+                // best-effort
+            }
+        }
+    } catch {
+        // directory may not exist yet
+    }
+
+    return removed;
+}
+
+async function gcSyncedJsonFiles(input: {
+    spoolRoot: string;
+    serviceId: string;
+    syncedRetentionMs: number;
+    nowMs: number;
+}): Promise<number> {
+    let removed = 0;
+
+    for (const processRole of resolveAllLogSpoolProcessRoles()) {
+        const processDir = logSpoolProcessDir(input.spoolRoot, input.serviceId, processRole);
+        let names: string[] = [];
+        try {
+            names = await readdir(processDir);
+        } catch {
+            continue;
+        }
+
+        for (const name of names) {
+            if (!name.endsWith(".json")) {
+                continue;
+            }
+            if (parseLogSpoolBatchFilename(name) == null) {
+                continue;
+            }
+
+            const jsonPath = join(processDir, name);
+            try {
+                const fileStat = await stat(jsonPath);
+                if (input.nowMs - fileStat.mtimeMs <= input.syncedRetentionMs) {
+                    continue;
+                }
+                await unlink(jsonPath);
+                removed += 1;
+                spoolLogger.info("collect-log gc removed synced json", {
+                    fileName: name,
+                    processRole,
+                });
+            } catch {
+                // best-effort
+            }
+        }
+    }
+
+    return removed;
+}
+
+function shouldRunGc(serviceId: string, nowMs: number, intervalMs: number): boolean {
+    const lastAt = lastGcAtMsByServiceId.get(serviceId) ?? 0;
+    if (nowMs - lastAt < intervalMs) {
+        return false;
+    }
+    lastGcAtMsByServiceId.set(serviceId, nowMs);
+    return true;
+}
+
+/**
+ * Guard-only: upload pending `.tmp` batches, rename to `.json`, then periodic GC.
+ * Upload completion is implied by `.json` presence; no sync-state file.
+ */
+export async function runCollectLogTick(input: RunCollectLogTickInput): Promise<RunCollectLogTickResult> {
+    const config = resolveLogSpoolConfig(input.config);
+    const spoolRoot = input.spoolRoot ?? resolveLogSpoolRoot();
+    const nowMs = input.nowMs ?? Date.now();
+
+    const result: RunCollectLogTickResult = {
+        uploaded: 0,
+        skipped: 0,
+        failed: 0,
+        gcTmpRemoved: 0,
+        gcSyncedRemoved: 0,
+    };
+
+    for (const processRole of resolveAllLogSpoolProcessRoles()) {
+        const processDir = logSpoolProcessDir(spoolRoot, input.serviceId, processRole);
+        let names: string[] = [];
+        try {
+            names = await readdir(processDir);
+        } catch {
+            continue;
+        }
+
+        for (const name of names) {
+            if (!name.endsWith(".tmp")) {
+                continue;
+            }
+            const status = await uploadTmpBatch({
+                serviceId: input.serviceId,
+                serviceValue: input.serviceValue,
+                processRole,
+                tmpPath: join(processDir, name),
+                fileName: name,
+                spoolRoot,
+                postTimeoutMs: config.writer.postTimeoutMs,
+            });
+            if (status === "uploaded") {
+                result.uploaded += 1;
+            } else if (status === "skipped") {
+                result.skipped += 1;
+            } else {
+                result.failed += 1;
+            }
+        }
+    }
+
+    if (shouldRunGc(input.serviceId, nowMs, config.gc.intervalMs)) {
+        for (const processRole of resolveAllLogSpoolProcessRoles()) {
+            result.gcTmpRemoved += await gcTmpFiles({
+                spoolRoot,
+                serviceId: input.serviceId,
+                processRole,
+                tmpRetentionMs: config.gc.tmpRetentionMs,
+                nowMs,
+            });
+        }
+
+        result.gcSyncedRemoved = await gcSyncedJsonFiles({
+            spoolRoot,
+            serviceId: input.serviceId,
+            syncedRetentionMs: config.gc.syncedRetentionMs,
+            nowMs,
+        });
+    }
+
+    if (result.uploaded > 0 || result.failed > 0) {
+        spoolLogger.info("collect-log tick complete", { ...result, serviceId: input.serviceId });
+    }
+
+    return result;
+}

package/src/shared/log/spool/config.ts

@@ -0,0 +1,56 @@
+import { envInt, envMs } from "../../../node/env/env-parsers";
+import type { LogSpoolConfig } from "./interface";
+
+export const LOG_SPOOL_SERVICE_ID_ENV = "LOG_SPOOL_SERVICE_ID";
+
+export const DEFAULT_LOG_SPOOL_CONFIG: LogSpoolConfig = {
+    writer: {
+        maxEntries: 2000,
+        maxBytes: 2 * 1024 * 1024,
+        flushDebounceMs: 3_000,
+        maxAgeMs: 60_000,
+        postTimeoutMs: 30_000,
+    },
+    gc: {
+        intervalMs: 24 * 60 * 60 * 1000,
+        syncedRetentionMs: 7 * 24 * 60 * 60 * 1000,
+        tmpRetentionMs: 7 * 24 * 60 * 60 * 1000,
+    },
+    collectIntervalMs: 60_000,
+};
+
+export function resolveLogSpoolConfig(partial?: Partial<LogSpoolConfig>): LogSpoolConfig {
+    const defaults = DEFAULT_LOG_SPOOL_CONFIG;
+    return {
+        writer: { ...defaults.writer, ...partial?.writer },
+        gc: { ...defaults.gc, ...partial?.gc },
+        collectIntervalMs: partial?.collectIntervalMs ?? defaults.collectIntervalMs,
+    };
+}
+
+export function logSpoolConfigFromEnv(env: NodeJS.ProcessEnv = process.env): LogSpoolConfig {
+    return resolveLogSpoolConfig({
+        writer: {
+            maxEntries: envInt("LOG_SPOOL_MAX_ENTRIES", DEFAULT_LOG_SPOOL_CONFIG.writer.maxEntries, { env, min: 1 }),
+            maxBytes: envInt("LOG_SPOOL_MAX_BYTES", DEFAULT_LOG_SPOOL_CONFIG.writer.maxBytes, { env, min: 1 }),
+            flushDebounceMs: envMs("LOG_SPOOL_FLUSH_DEBOUNCE_MS", DEFAULT_LOG_SPOOL_CONFIG.writer.flushDebounceMs, {
+                env,
+            }),
+            maxAgeMs: envMs("LOG_SPOOL_MAX_AGE_MS", DEFAULT_LOG_SPOOL_CONFIG.writer.maxAgeMs, { env }),
+            postTimeoutMs: envMs("LOG_PERSIST_POST_TIMEOUT_MS", DEFAULT_LOG_SPOOL_CONFIG.writer.postTimeoutMs, { env }),
+        },
+        gc: {
+            intervalMs: envMs("LOG_SPOOL_GC_INTERVAL_MS", DEFAULT_LOG_SPOOL_CONFIG.gc.intervalMs, { env }),
+            syncedRetentionMs: envMs("LOG_SPOOL_SYNCED_RETENTION_MS", DEFAULT_LOG_SPOOL_CONFIG.gc.syncedRetentionMs, {
+                env,
+            }),
+            tmpRetentionMs: envMs("LOG_SPOOL_TMP_RETENTION_MS", DEFAULT_LOG_SPOOL_CONFIG.gc.tmpRetentionMs, { env }),
+        },
+        collectIntervalMs: envMs("LOG_SPOOL_COLLECT_INTERVAL_MS", DEFAULT_LOG_SPOOL_CONFIG.collectIntervalMs, { env }),
+    });
+}
+
+export function logSpoolServiceIdFromEnv(env: NodeJS.ProcessEnv = process.env): string | undefined {
+    const raw = env[LOG_SPOOL_SERVICE_ID_ENV]?.trim();
+    return raw != null && raw !== "" ? raw : undefined;
+}

package/src/shared/log/spool/coordinator.ts

@@ -0,0 +1,55 @@
+import { ensureLogSpoolFromEnv, getLogSpoolStats, logSpoolEnabledFromEnv, shutdownLogSpoolFromEnv } from "./enable";
+import type { LogSpoolWriterStats } from "./interface";
+
+export interface LogSpoolCoordinatorOptions {
+    /** Logical service value (e.g. `watch-service`). */
+    serviceValue: string;
+    /** Instance id after registry claim — passed to child spawn env. */
+    serviceId: string;
+}
+
+/** Service-bound facade for file log spool writer lifecycle. */
+export interface LogSpoolCoordinator {
+    isEnabled(): boolean;
+    getServiceId(): string;
+    /** Enable spool writer in this process. */
+    registerProcess(process?: string): Promise<boolean>;
+    getWriterStats(): LogSpoolWriterStats | null;
+    shutdownLogSpool(): Promise<void>;
+}
+
+export function createLogSpoolCoordinator(options: LogSpoolCoordinatorOptions): LogSpoolCoordinator {
+    const { serviceValue, serviceId } = options;
+
+    return {
+        isEnabled() {
+            return logSpoolEnabledFromEnv();
+        },
+
+        getServiceId() {
+            return serviceId;
+        },
+
+        registerProcess(process?: string) {
+            return ensureLogSpoolFromEnv({
+                serviceValue,
+                serviceId,
+                processRole: process,
+            });
+        },
+
+        getWriterStats() {
+            if (!logSpoolEnabledFromEnv()) {
+                return null;
+            }
+            return getLogSpoolStats();
+        },
+
+        async shutdownLogSpool() {
+            if (!logSpoolEnabledFromEnv()) {
+                return;
+            }
+            await shutdownLogSpoolFromEnv();
+        },
+    };
+}

package/src/shared/log/spool/enable.ts

@@ -0,0 +1,136 @@
+import { createLogger } from "../core/create-logger";
+import { logPersistProcessFromEnv, logPersistServiceFromEnv, logSpoolEnabledFromEnv } from "../upload/env";
+import { registerLogPersistOffer } from "../upload/hook";
+import { LOG_PERSIST_TOPIC } from "../upload/logger";
+import { LOG_SPOOL_SERVICE_ID_ENV, logSpoolConfigFromEnv, logSpoolServiceIdFromEnv } from "./config";
+import type { EnsureLogSpoolFromEnvOptions, LogSpoolProcessRole } from "./interface";
+import { resolveLogSpoolRoot } from "./paths";
+import {
+    assertValidLogSpoolExtraProcessRole,
+    isKnownLogSpoolProcessRole,
+    LOG_SPOOL_EXTRA_PROCESS_ROLES_ENV,
+} from "./process-roles";
+import { enableLogSpoolWriter, getLogSpoolWriterStats, shutdownLogSpoolWriter } from "./writer";
+
+export { logSpoolEnabledFromEnv };
+
+export function resolveLogSpoolProcessRole(explicit?: string): LogSpoolProcessRole {
+    const raw = explicit ?? logPersistProcessFromEnv();
+    if (raw == null || raw === "") {
+        throw new Error("[LogSpool] LOG_PERSIST_PROCESS is required when LOG_PERSIST_ENABLED=true");
+    }
+    if (!isKnownLogSpoolProcessRole(raw)) {
+        throw new Error(
+            `[LogSpool] invalid LOG_PERSIST_PROCESS: ${raw} (not a core role and not listed in ${LOG_SPOOL_EXTRA_PROCESS_ROLES_ENV})`,
+        );
+    }
+    return raw;
+}
+
+/**
+ * Env vars for child spawn after main claims registry slot.
+ * Optional when using {@link ManagedChildProcesses.spawn} — auto-injected from parent env.
+ */
+export function buildLogSpoolSpawnEnv(input: {
+    serviceId: string;
+    processRole: LogSpoolProcessRole;
+}): Record<string, string> {
+    return {
+        [LOG_SPOOL_SERVICE_ID_ENV]: input.serviceId,
+        LOG_PERSIST_PROCESS: input.processRole,
+    };
+}
+
+/**
+ * When persistence is enabled and parent has `LOG_SPOOL_SERVICE_ID`, map spawn `label`
+ * to spool env when `label` is a known core or extra process role.
+ */
+export function resolveLogSpoolSpawnEnvForLabel(
+    label: string,
+    env: NodeJS.ProcessEnv = process.env,
+): Record<string, string> {
+    if (!logSpoolEnabledFromEnv(env)) {
+        return {};
+    }
+    const serviceId = env[LOG_SPOOL_SERVICE_ID_ENV]?.trim();
+    if (serviceId == null || serviceId === "") {
+        return {};
+    }
+    if (!isKnownLogSpoolProcessRole(label, env)) {
+        return {};
+    }
+    return buildLogSpoolSpawnEnv({ serviceId, processRole: label });
+}
+
+export async function ensureLogSpoolFromEnv(options: EnsureLogSpoolFromEnvOptions = {}): Promise<boolean> {
+    if (!logSpoolEnabledFromEnv()) {
+        registerLogPersistOffer(null);
+        return false;
+    }
+
+    const serviceId = options.serviceId ?? logSpoolServiceIdFromEnv();
+    const serviceValue = options.serviceValue ?? logPersistServiceFromEnv();
+    const processRole = resolveLogSpoolProcessRole(options.processRole);
+
+    if (serviceId == null || serviceId === "") {
+        throw new Error(
+            "[LogSpool] LOG_SPOOL_SERVICE_ID is required when LOG_PERSIST_ENABLED=true (set after registry claim or pass serviceId)",
+        );
+    }
+    if (serviceValue == null || serviceValue === "") {
+        throw new Error("[LogSpool] LOG_PERSIST_SERVICE is required when LOG_PERSIST_ENABLED=true");
+    }
+
+    const spoolRoot = options.spoolRoot ?? resolveLogSpoolRoot();
+
+    await enableLogSpoolWriter({
+        serviceId,
+        processRole,
+        serviceValue,
+        spoolRoot,
+        config: options.config ?? logSpoolConfigFromEnv(),
+    });
+
+    const lifecycleLogger = createLogger({ module: "log-spool" });
+    lifecycleLogger.info("log spool enabled from env", {
+        topic: LOG_PERSIST_TOPIC,
+        data: { serviceId, processRole, serviceValue, spoolRoot },
+    });
+
+    return true;
+}
+
+export async function shutdownLogSpoolFromEnv(): Promise<void> {
+    await shutdownLogSpoolWriter();
+}
+
+export function getLogSpoolStats(): ReturnType<typeof getLogSpoolWriterStats> {
+    return getLogSpoolWriterStats();
+}
+
+export function validateLogSpoolPreloadEnv(env: NodeJS.ProcessEnv = process.env): void {
+    if (!logSpoolEnabledFromEnv(env)) {
+        return;
+    }
+
+    const missing: string[] = [];
+    if (env.LOG_PERSIST_SERVICE?.trim() == null || env.LOG_PERSIST_SERVICE.trim() === "") {
+        missing.push("LOG_PERSIST_SERVICE");
+    }
+    const runtimeDir = env.LOG_PERSIST_REGISTRY_DIR?.trim() || env.RUNTIME_DATA_DIR?.trim();
+    if (runtimeDir == null || runtimeDir === "") {
+        missing.push("LOG_PERSIST_REGISTRY_DIR or RUNTIME_DATA_DIR");
+    }
+
+    if (missing.length > 0) {
+        throw new Error(`[LogSpool] preload env incomplete: ${missing.join(", ")}`);
+    }
+
+    for (const role of env[LOG_SPOOL_EXTRA_PROCESS_ROLES_ENV]?.split(",") ?? []) {
+        const trimmed = role.trim();
+        if (trimmed === "") {
+            continue;
+        }
+        assertValidLogSpoolExtraProcessRole(trimmed);
+    }
+}

package/src/shared/log/spool/file.ts

@@ -0,0 +1,75 @@
+import type { LogEntry } from "../core/log-manager";
+import { computeLogBatchIdempotencyKey } from "../upload/batch-id";
+import type { LogSpoolProcessRole } from "./interface";
+
+/** `role.timestamp.hash.tmp|json` — role is lowercase alphanumeric + hyphen. */
+const BATCH_FILE_PATTERN = /^([a-z][a-z0-9-]*)\.(\d{14})\.([a-f0-9]{8})\.(tmp|json)$/;
+
+export function formatLogSpoolBatchTimestamp(ms: number): string {
+    const d = new Date(ms);
+    const pad = (n: number) => String(n).padStart(2, "0");
+    return (
+        `${d.getFullYear()}` +
+        `${pad(d.getMonth() + 1)}` +
+        `${pad(d.getDate())}` +
+        `${pad(d.getHours())}` +
+        `${pad(d.getMinutes())}` +
+        `${pad(d.getSeconds())}`
+    );
+}
+
+export function computeLogSpoolShortHash(input: {
+    serviceValue: string;
+    serviceId: string;
+    processRole: LogSpoolProcessRole;
+    entries: LogEntry[];
+}): string {
+    const processKey = `${input.serviceId}:${input.processRole}`;
+    const idempotencyKey = computeLogBatchIdempotencyKey({
+        service: input.serviceValue,
+        process: processKey,
+        lane: "slow",
+        entries: input.entries,
+    });
+    return idempotencyKey.slice(0, 8);
+}
+
+export function buildLogSpoolBatchBaseName(input: {
+    processRole: LogSpoolProcessRole;
+    firstEntryTimestamp: number;
+    shortHash: string;
+}): string {
+    const ts = formatLogSpoolBatchTimestamp(input.firstEntryTimestamp);
+    return `${input.processRole}.${ts}.${input.shortHash}`;
+}
+
+export function parseLogSpoolBatchFilename(filename: string): {
+    processRole: LogSpoolProcessRole;
+    timestampMs: number;
+    shortHash: string;
+    extension: "tmp" | "json";
+} | null {
+    const match = BATCH_FILE_PATTERN.exec(filename);
+    if (match == null) {
+        return null;
+    }
+
+    const processRole = match[1] as LogSpoolProcessRole;
+    const tsRaw = match[2];
+    const shortHash = match[3];
+    const extension = match[4] as "tmp" | "json";
+
+    const year = Number(tsRaw.slice(0, 4));
+    const month = Number(tsRaw.slice(4, 6));
+    const day = Number(tsRaw.slice(6, 8));
+    const hour = Number(tsRaw.slice(8, 10));
+    const minute = Number(tsRaw.slice(10, 12));
+    const second = Number(tsRaw.slice(12, 14));
+    const timestampMs = Date.UTC(year, month - 1, day, hour, minute, second);
+
+    if (!Number.isFinite(timestampMs)) {
+        return null;
+    }
+
+    return { processRole, timestampMs, shortHash, extension };
+}