opencode-translate 0.1.2 → 0.1.3

package/src/constants/errors.ts

@@ -0,0 +1,24 @@
+import { PLUGIN_NAME } from "./plugin"
+
+export function normalizeReason(error: unknown): string {
+  const raw = error instanceof Error ? error.message : String(error)
+  return raw.split(/\r?\n/, 1)[0].trim().slice(0, 200)
+}
+
+export function buildInboundTranslationError(sourceLanguage: string, reason: string): Error {
+  return new Error(
+    `[${PLUGIN_NAME}:INBOUND_TRANSLATION_FAILED] Failed to translate user message from ${sourceLanguage} to en: ${reason}`,
+  )
+}
+
+export function buildAuthUnavailableError(providerID: string, envVar: string): Error {
+  return new Error(
+    `[${PLUGIN_NAME}:AUTH_UNAVAILABLE] No credential found for provider "${providerID}". Set ${envVar} in the environment, run "opencode auth login ${providerID}", or set options.apiKey in opencode.json.`,
+  )
+}
+
+export function buildOAuthRefreshError(providerID: string, reason: string): Error {
+  return new Error(
+    `[${PLUGIN_NAME}:OAUTH_REFRESH_FAILED] Failed to refresh OAuth token for provider "${providerID}": ${reason}. Re-authenticate with "opencode auth login ${providerID}".`,
+  )
+}

package/src/constants/guards.ts

@@ -0,0 +1,34 @@
+import { LLM_LANGUAGE, NONCE_PATTERN } from "./plugin"
+import type { SDKResponseLike, TextPartLike, TranslateState } from "./types"
+
+function isNonEmptyString(value: unknown): value is string {
+  return typeof value === "string" && value.length > 0
+}
+
+export function unwrapData<T>(value: T | SDKResponseLike<T>): T {
+  if (value && typeof value === "object" && "data" in value && (value as SDKResponseLike<T>).data !== undefined) {
+    return (value as SDKResponseLike<T>).data as T
+  }
+  return value as T
+}
+
+export function isTranslateStateRecord(value: unknown): value is TranslateState {
+  if (!value || typeof value !== "object") return false
+  const record = value as Record<string, unknown>
+  return (
+    record.translate_enabled === true &&
+    record.translate_llm_lang === LLM_LANGUAGE &&
+    isNonEmptyString(record.translate_source_lang) &&
+    isNonEmptyString(record.translate_display_lang) &&
+    isNonEmptyString(record.translate_nonce) &&
+    NONCE_PATTERN.test(record.translate_nonce)
+  )
+}
+
+export function isTextPart(part: TextPartLike): part is TextPartLike & { text: string } {
+  return part.type === "text" && typeof part.text === "string"
+}
+
+export function isUserAuthoredTextPart(part: TextPartLike): part is TextPartLike & { text: string } {
+  return isTextPart(part) && part.synthetic !== true && part.ignored !== true
+}

package/src/constants/options.ts

@@ -0,0 +1,37 @@
+import { AUTH_ENV_FALLBACK, DEFAULT_TRANSLATOR_MODEL, DEFAULT_TRIGGER_KEYWORDS } from "./plugin"
+import type { ProviderInfo, ResolvedTranslateOptions } from "./types"
+
+export function resolveOptions(options: Record<string, unknown>): ResolvedTranslateOptions {
+  const triggerKeywords = Array.isArray(options.triggerKeywords)
+    ? options.triggerKeywords.filter((value): value is string => typeof value === "string" && value.length > 0)
+    : DEFAULT_TRIGGER_KEYWORDS
+
+  return {
+    translatorModel:
+      typeof options.translatorModel === "string" && options.translatorModel.includes("/")
+        ? options.translatorModel
+        : DEFAULT_TRANSLATOR_MODEL,
+    triggerKeywords: triggerKeywords.length > 0 ? triggerKeywords : [...DEFAULT_TRIGGER_KEYWORDS],
+    sourceLanguage:
+      typeof options.sourceLanguage === "string" && options.sourceLanguage.trim() ? options.sourceLanguage : "en",
+    displayLanguage:
+      typeof options.displayLanguage === "string" && options.displayLanguage.trim() ? options.displayLanguage : "en",
+    apiKey: typeof options.apiKey === "string" && options.apiKey.length > 0 ? options.apiKey : undefined,
+    verbose: options.verbose === true,
+  }
+}
+
+export function getEnvVarHint(provider: ProviderInfo | undefined): string {
+  return provider?.env[0] || AUTH_ENV_FALLBACK
+}
+
+export function parseTranslatorModel(model: string): { providerID: string; modelID: string } {
+  const slash = model.indexOf("/")
+  if (slash < 1 || slash === model.length - 1) {
+    return { providerID: "anthropic", modelID: model }
+  }
+  return {
+    providerID: model.slice(0, slash),
+    modelID: model.slice(slash + 1),
+  }
+}

package/src/constants/plugin.ts

@@ -0,0 +1,10 @@
+export const PLUGIN_NAME = "opencode-translate"
+export const SPEC_VERSION = 1
+export const LLM_LANGUAGE = "en"
+export const DEFAULT_TRANSLATOR_MODEL = "anthropic/claude-haiku-4-5"
+export const DEFAULT_TRIGGER_KEYWORDS = ["$en"]
+export const OAUTH_DUMMY_KEY = "opencode-oauth-dummy-key"
+export const NONCE_PATTERN = /^[0-9a-f]{32}$/
+export const FAILURE_NOTICE = "_Translation unavailable for this segment._"
+export const AUTH_ENV_FALLBACK = "the provider's API key env var"
+export const USER_AGENT = `${PLUGIN_NAME}/0.0.0`

package/src/constants/types.ts

@@ -0,0 +1,147 @@
+import type { LLM_LANGUAGE } from "./plugin"
+
+export type FetchLike = (input: RequestInfo | URL, init?: RequestInit) => Promise<Response>
+
+type ProviderSource = "env" | "config" | "custom" | "api"
+
+export interface ResolvedTranslateOptions {
+  translatorModel: string
+  triggerKeywords: string[]
+  sourceLanguage: string
+  displayLanguage: string
+  apiKey?: string
+  verbose: boolean
+}
+
+export interface TranslateState {
+  translate_enabled: true
+  translate_source_lang: string
+  translate_display_lang: string
+  translate_llm_lang: typeof LLM_LANGUAGE
+  translate_nonce: string
+}
+
+export interface StoredTextMetadata extends Record<string, unknown> {
+  translate_enabled?: boolean
+  translate_source_lang?: string
+  translate_display_lang?: string
+  translate_llm_lang?: string
+  translate_nonce?: string
+  translate_role?: string
+  translate_spec_version?: number
+  translate_source_hash?: string
+  translate_en?: string
+  translate_part_index?: number
+  compaction_continue?: boolean
+}
+
+interface SessionLike {
+  id: string
+  parentID?: string | null
+}
+
+interface MessageLike {
+  id: string
+  sessionID: string
+  role: string
+}
+
+export interface TextPartLike {
+  id: string
+  sessionID: string
+  messageID: string
+  type: string
+  text?: string
+  synthetic?: boolean
+  ignored?: boolean
+  metadata?: Record<string, unknown>
+}
+
+export interface MessageWithPartsLike {
+  info: MessageLike
+  parts: TextPartLike[]
+}
+
+export interface ProviderInfo {
+  id: string
+  source: ProviderSource
+  env: string[]
+  key?: string
+  options?: Record<string, unknown>
+  models?: Record<string, unknown>
+}
+
+interface ProviderListResponseLike {
+  all: ProviderInfo[]
+}
+
+interface ApiAuthInfo {
+  type: "api"
+  key: string
+  metadata?: Record<string, string>
+}
+
+export interface OAuthInfo {
+  type: "oauth"
+  refresh: string
+  access: string
+  expires: number
+  accountId?: string
+  enterpriseUrl?: string
+}
+
+interface WellKnownInfo {
+  type: "wellknown"
+  key: string
+  token: string
+}
+
+export type AuthInfo = ApiAuthInfo | OAuthInfo | WellKnownInfo
+
+export interface SDKResponseLike<T> {
+  data?: T
+}
+
+export interface PluginClientLike {
+  session: {
+    get(
+      input: (
+        | { sessionID: string; directory?: string; workspace?: string }
+        | { path: { id: string }; query?: { directory?: string; workspace?: string } }
+      ) & { throwOnError?: boolean },
+      options?: { throwOnError?: boolean },
+    ): Promise<SessionLike | SDKResponseLike<SessionLike>>
+    messages(
+      input: (
+        | { sessionID: string; directory?: string; workspace?: string }
+        | { path: { id: string }; query?: { directory?: string; workspace?: string; limit?: number; before?: string } }
+      ) & { throwOnError?: boolean },
+      options?: { throwOnError?: boolean },
+    ): Promise<MessageWithPartsLike[] | SDKResponseLike<MessageWithPartsLike[]>>
+    message(
+      input: (
+        | { sessionID: string; messageID: string; directory?: string; workspace?: string }
+        | { path: { id: string; messageID: string }; query?: { directory?: string; workspace?: string } }
+      ) & { throwOnError?: boolean },
+      options?: { throwOnError?: boolean },
+    ): Promise<MessageWithPartsLike | SDKResponseLike<MessageWithPartsLike>>
+  }
+  provider: {
+    list(options?: {
+      throwOnError?: boolean
+    }): Promise<ProviderListResponseLike | SDKResponseLike<ProviderListResponseLike>>
+  }
+  auth: {
+    set(input: { path: { id: string }; body: AuthInfo }): Promise<unknown>
+  }
+  app: {
+    log(input: {
+      body: {
+        service: string
+        level: string
+        message: string
+        extra?: Record<string, unknown>
+      }
+    }): Promise<unknown>
+  }
+}

package/src/constants.ts

@@ -1,261 +1,5 @@
-export const PLUGIN_NAME = "opencode-translate"
-export const SPEC_VERSION = 1
-export const LLM_LANGUAGE = "en"
-export const DEFAULT_TRANSLATOR_MODEL = "anthropic/claude-haiku-4-5"
-export const DEFAULT_TRIGGER_KEYWORDS = ["$en"]
-export const OAUTH_DUMMY_KEY = "opencode-oauth-dummy-key"
-export const NONCE_PATTERN = /^[0-9a-f]{32}$/
-export const FAILURE_NOTICE = "_Translation unavailable for this segment._"
-export const AUTH_ENV_FALLBACK = "the provider's API key env var"
-export const USER_AGENT = `${PLUGIN_NAME}/0.0.0`
-
-export type FetchLike = (input: RequestInfo | URL, init?: RequestInit) => Promise<Response>
-
-export type ProviderSource = "env" | "config" | "custom" | "api"
-
-export interface TranslateOptions {
-  translatorModel?: string
-  triggerKeywords?: string[]
-  sourceLanguage?: string
-  displayLanguage?: string
-  apiKey?: string
-  verbose?: boolean
-}
-
-export interface ResolvedTranslateOptions {
-  translatorModel: string
-  triggerKeywords: string[]
-  sourceLanguage: string
-  displayLanguage: string
-  apiKey?: string
-  verbose: boolean
-}
-
-export interface TranslateState {
-  translate_enabled: true
-  translate_source_lang: string
-  translate_display_lang: string
-  translate_llm_lang: typeof LLM_LANGUAGE
-  translate_nonce: string
-}
-
-export interface StoredTextMetadata extends Record<string, unknown> {
-  translate_enabled?: boolean
-  translate_source_lang?: string
-  translate_display_lang?: string
-  translate_llm_lang?: string
-  translate_nonce?: string
-  translate_role?: string
-  translate_spec_version?: number
-  translate_source_hash?: string
-  translate_en?: string
-  translate_part_index?: number
-  compaction_continue?: boolean
-}
-
-export interface SessionLike {
-  id: string
-  parentID?: string | null
-}
-
-export interface MessageLike {
-  id: string
-  sessionID: string
-  role: string
-}
-
-export interface TextPartLike {
-  id: string
-  sessionID: string
-  messageID: string
-  type: string
-  text?: string
-  synthetic?: boolean
-  ignored?: boolean
-  metadata?: Record<string, unknown>
-}
-
-export interface MessageWithPartsLike {
-  info: MessageLike
-  parts: TextPartLike[]
-}
-
-export interface ProviderInfo {
-  id: string
-  source: ProviderSource
-  env: string[]
-  key?: string
-  options?: Record<string, unknown>
-  models?: Record<string, unknown>
-}
-
-export interface ProviderListResponseLike {
-  all: ProviderInfo[]
-}
-
-export interface ApiAuthInfo {
-  type: "api"
-  key: string
-  metadata?: Record<string, string>
-}
-
-export interface OAuthInfo {
-  type: "oauth"
-  refresh: string
-  access: string
-  expires: number
-  accountId?: string
-  enterpriseUrl?: string
-}
-
-export interface WellKnownInfo {
-  type: "wellknown"
-  key: string
-  token: string
-}
-
-export type AuthInfo = ApiAuthInfo | OAuthInfo | WellKnownInfo
-
-export interface SDKResponseLike<T> {
-  data?: T
-}
-
-export interface PluginClientLike {
-  session: {
-    get(
-      input: (
-        | { sessionID: string; directory?: string; workspace?: string }
-        | { path: { id: string }; query?: { directory?: string; workspace?: string } }
-      ) & { throwOnError?: boolean },
-      options?: { throwOnError?: boolean },
-    ): Promise<SessionLike | SDKResponseLike<SessionLike>>
-    messages(
-      input: (
-        | { sessionID: string; directory?: string; workspace?: string }
-        | { path: { id: string }; query?: { directory?: string; workspace?: string; limit?: number; before?: string } }
-      ) & { throwOnError?: boolean },
-      options?: { throwOnError?: boolean },
-    ): Promise<MessageWithPartsLike[] | SDKResponseLike<MessageWithPartsLike[]>>
-    message(
-      input: (
-        | { sessionID: string; messageID: string; directory?: string; workspace?: string }
-        | { path: { id: string; messageID: string }; query?: { directory?: string; workspace?: string } }
-      ) & { throwOnError?: boolean },
-      options?: { throwOnError?: boolean },
-    ): Promise<MessageWithPartsLike | SDKResponseLike<MessageWithPartsLike>>
-  }
-  provider: {
-    list(options?: {
-      throwOnError?: boolean
-    }): Promise<ProviderListResponseLike | SDKResponseLike<ProviderListResponseLike>>
-  }
-  auth: {
-    set(input: { path: { id: string }; body: AuthInfo }): Promise<unknown>
-  }
-  app: {
-    log(input: {
-      body: {
-        service: string
-        level: string
-        message: string
-        extra?: Record<string, unknown>
-      }
-    }): Promise<unknown>
-  }
-}
-
-export interface TranslationPreviewInfo {
-  english: string
-  sourceHash: string
-  eligibleIndex: number
-}
-
-export function resolveOptions(options: Record<string, unknown>): ResolvedTranslateOptions {
-  const triggerKeywords = Array.isArray(options.triggerKeywords)
-    ? options.triggerKeywords.filter((value): value is string => typeof value === "string" && value.length > 0)
-    : DEFAULT_TRIGGER_KEYWORDS
-
-  return {
-    translatorModel:
-      typeof options.translatorModel === "string" && options.translatorModel.includes("/")
-        ? options.translatorModel
-        : DEFAULT_TRANSLATOR_MODEL,
-    triggerKeywords: triggerKeywords.length > 0 ? triggerKeywords : [...DEFAULT_TRIGGER_KEYWORDS],
-    sourceLanguage:
-      typeof options.sourceLanguage === "string" && options.sourceLanguage.trim() ? options.sourceLanguage : "en",
-    displayLanguage:
-      typeof options.displayLanguage === "string" && options.displayLanguage.trim() ? options.displayLanguage : "en",
-    apiKey: typeof options.apiKey === "string" && options.apiKey.length > 0 ? options.apiKey : undefined,
-    verbose: options.verbose === true,
-  }
-}
-
-export function getEnvVarHint(provider: ProviderInfo | undefined): string {
-  return provider?.env[0] || AUTH_ENV_FALLBACK
-}
-
-export function isNonEmptyString(value: unknown): value is string {
-  return typeof value === "string" && value.length > 0
-}
-
-export function unwrapData<T>(value: T | SDKResponseLike<T>): T {
-  if (value && typeof value === "object" && "data" in value && (value as SDKResponseLike<T>).data !== undefined) {
-    return (value as SDKResponseLike<T>).data as T
-  }
-  return value as T
-}
-
-export function normalizeReason(error: unknown): string {
-  const raw = error instanceof Error ? error.message : String(error)
-  return raw.split(/\r?\n/, 1)[0].trim().slice(0, 200)
-}
-
-export function buildInboundTranslationError(sourceLanguage: string, reason: string): Error {
-  return new Error(
-    `[${PLUGIN_NAME}:INBOUND_TRANSLATION_FAILED] Failed to translate user message from ${sourceLanguage} to en: ${reason}`,
-  )
-}
-
-export function buildAuthUnavailableError(providerID: string, envVar: string): Error {
-  return new Error(
-    `[${PLUGIN_NAME}:AUTH_UNAVAILABLE] No credential found for provider "${providerID}". Set ${envVar} in the environment, run "opencode auth login ${providerID}", or set options.apiKey in opencode.json.`,
-  )
-}
-
-export function buildOAuthRefreshError(providerID: string, reason: string): Error {
-  return new Error(
-    `[${PLUGIN_NAME}:OAUTH_REFRESH_FAILED] Failed to refresh OAuth token for provider "${providerID}": ${reason}. Re-authenticate with "opencode auth login ${providerID}".`,
-  )
-}
-
-export function isTranslateStateRecord(value: unknown): value is TranslateState {
-  if (!value || typeof value !== "object") return false
-  const record = value as Record<string, unknown>
-  return (
-    record.translate_enabled === true &&
-    record.translate_llm_lang === LLM_LANGUAGE &&
-    isNonEmptyString(record.translate_source_lang) &&
-    isNonEmptyString(record.translate_display_lang) &&
-    isNonEmptyString(record.translate_nonce) &&
-    NONCE_PATTERN.test(record.translate_nonce)
-  )
-}
-
-export function isTextPart(part: TextPartLike): part is TextPartLike & { text: string } {
-  return part.type === "text" && typeof part.text === "string"
-}
-
-export function isUserAuthoredTextPart(part: TextPartLike): part is TextPartLike & { text: string } {
-  return isTextPart(part) && part.synthetic !== true && part.ignored !== true
-}
-
-export function parseTranslatorModel(model: string): { providerID: string; modelID: string } {
-  const slash = model.indexOf("/")
-  if (slash < 1 || slash === model.length - 1) {
-    return { providerID: "anthropic", modelID: model }
-  }
-  return {
-    providerID: model.slice(0, slash),
-    modelID: model.slice(slash + 1),
-  }
-}
+export * from "./constants/errors"
+export * from "./constants/guards"
+export * from "./constants/options"
+export * from "./constants/plugin"
+export * from "./constants/types"

package/src/labels.ts

@@ -13,5 +13,3 @@ const DISPLAY_LANGUAGE_LABELS: Record<string, string> = {
 export function getDisplayLanguageLabel(displayLanguage: string): string {
   return DISPLAY_LANGUAGE_LABELS[displayLanguage] ?? `Translation (${displayLanguage})`
 }
-
-export { DISPLAY_LANGUAGE_LABELS }

package/src/translator/index.ts

@@ -0,0 +1,125 @@
+import { setTimeout as sleep } from "node:timers/promises"
+import { generateText } from "ai"
+import { createCredentialResolver } from "../auth"
+import {
+  buildAuthUnavailableError,
+  PLUGIN_NAME,
+  type PluginClientLike,
+  type ProviderInfo,
+  parseTranslatorModel,
+  type ResolvedTranslateOptions,
+} from "../constants"
+import { buildSystemPrompt, buildUserPrompt, unwrapEchoedTextEnvelope } from "../prompts"
+import { __resetSyntheticPartIDForTest } from "./part-id"
+import {
+  __resetProviderFactoryCacheForTest,
+  instantiateModel,
+  instantiateProvider,
+  loadFactory,
+  supportsTemperature,
+} from "./provider"
+import { withRetry } from "./retry"
+import type { TranslateTextInput, TranslatorDependencies } from "./types"
+
+const DEFAULT_TRANSLATE_TIMEOUT_MS = 180_000
+
+function withTimeout<T>(promise: Promise<T>, timeoutMs: number, label: string): Promise<T> {
+  return new Promise<T>((resolve, reject) => {
+    const timer = setTimeout(() => reject(new Error(`${label} timed out after ${timeoutMs}ms`)), timeoutMs)
+    promise.then(
+      (value) => {
+        clearTimeout(timer)
+        resolve(value)
+      },
+      (error) => {
+        clearTimeout(timer)
+        reject(error)
+      },
+    )
+  })
+}
+
+function isAuthMessage(error: unknown): boolean {
+  if (!(error instanceof Error)) return false
+  return error.message.includes(":AUTH_UNAVAILABLE]") || error.message.includes(":OAUTH_REFRESH_FAILED]")
+}
+
+function modelProviderHint(providerID: string, provider?: ProviderInfo): Error {
+  return buildAuthUnavailableError(providerID, provider?.env[0] || "the provider's API key env var")
+}
+
+export function __resetTranslatorCachesForTest() {
+  __resetProviderFactoryCacheForTest()
+  __resetSyntheticPartIDForTest()
+}
+
+export function createTranslator(
+  client: PluginClientLike,
+  options: ResolvedTranslateOptions,
+  deps: TranslatorDependencies = {},
+) {
+  const sleepImpl = deps.sleep ?? ((ms: number) => sleep(ms))
+  const now = deps.now ?? (() => Date.now())
+  const generateTextImpl = deps.generateTextImpl ?? generateText
+  const credentialResolver = deps.credentialResolver ?? createCredentialResolver(client, options)
+  const timeoutMs = deps.timeoutMs ?? DEFAULT_TRANSLATE_TIMEOUT_MS
+
+  async function translateText(input: TranslateTextInput): Promise<string> {
+    if (!input.text) return input.text
+    if (input.sourceLanguage === input.targetLanguage) return input.text
+
+    const startedAt = now()
+    const { providerID, modelID } = parseTranslatorModel(options.translatorModel)
+    const credentials = await credentialResolver.resolve(options.translatorModel)
+    const factory = await loadFactory(providerID)
+    const provider = instantiateProvider(factory, providerID, credentials)
+    const model = instantiateModel(provider, modelID)
+
+    const rawTranslated = await withRetry(async () => {
+      try {
+        const result = (await withTimeout(
+          generateTextImpl({
+            model: model as never,
+            system: buildSystemPrompt(input),
+            ...(supportsTemperature(providerID, modelID) ? { temperature: 0 } : {}),
+            prompt: buildUserPrompt(input),
+          }) as Promise<{ text: string }>,
+          timeoutMs,
+          "Translator generateText",
+        )) as { text: string }
+        return result.text
+      } catch (error) {
+        if (isAuthMessage(error)) throw error
+        if (credentials.mode === "default" && credentialResolver.isMissingCredentialError(error)) {
+          throw modelProviderHint(providerID, credentials.provider)
+        }
+        throw error
+      }
+    }, sleepImpl)
+    const translated = unwrapEchoedTextEnvelope(rawTranslated)
+
+    if (options.verbose) {
+      await client.app.log({
+        body: {
+          service: PLUGIN_NAME,
+          level: "info",
+          message: "translated",
+          extra: {
+            direction: input.direction,
+            chars_in: input.text.length,
+            chars_out: translated.length,
+            ms: now() - startedAt,
+            cached: false,
+            model: options.translatorModel,
+          },
+        },
+      })
+    }
+
+    return translated
+  }
+
+  return { translateText }
+}
+
+export { __resetSyntheticPartIDForTest, createSyntheticPartID, hashText } from "./part-id"

package/src/translator/part-id.ts

@@ -0,0 +1,43 @@
+import { createHash, randomBytes } from "node:crypto"
+
+const PART_ID_LENGTH = 26
+const PART_ID_PREFIX = "prt"
+const BASE62_CHARS = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz"
+
+let partLastTimestamp = 0
+let partCounter = 0
+
+export function __resetSyntheticPartIDForTest() {
+  partLastTimestamp = 0
+  partCounter = 0
+}
+
+function randomBase62(length: number): string {
+  const bytes = randomBytes(length)
+  let result = ""
+  for (let index = 0; index < length; index += 1) {
+    result += BASE62_CHARS[bytes[index] % BASE62_CHARS.length]
+  }
+  return result
+}
+
+export function hashText(text: string): string {
+  return createHash("sha256").update(text, "utf8").digest("hex").slice(0, 16)
+}
+
+export function createSyntheticPartID(): string {
+  const currentTimestamp = Date.now()
+  if (currentTimestamp !== partLastTimestamp) {
+    partLastTimestamp = currentTimestamp
+    partCounter = 0
+  }
+  partCounter += 1
+
+  const encoded = BigInt(currentTimestamp) * BigInt(0x1000) + BigInt(partCounter)
+  const timeBytes = Buffer.alloc(6)
+  for (let index = 0; index < 6; index += 1) {
+    timeBytes[index] = Number((encoded >> BigInt(40 - 8 * index)) & BigInt(0xff))
+  }
+
+  return `${PART_ID_PREFIX}_${timeBytes.toString("hex")}${randomBase62(PART_ID_LENGTH - 12)}`
+}