ima2-gen 1.1.21 → 1.1.23

package/lib/promptImport/promptIndex.ts

@@ -1,326 +0,0 @@
-import { createHash } from "node:crypto";
-import { mkdir, readFile, rename, writeFile } from "node:fs/promises";
-import { dirname } from "node:path";
-import { getCuratedSource, getDefaultSearchSources, listCuratedSources } from "./curatedSources.js";
-import { buildGitHubRawFileSource, fetchGitHubSource } from "./githubSource.js";
-import { parsePromptCandidates } from "./parsePromptCandidates.js";
-import { extractGptImageHints } from "./gptImageHints.js";
-import { rankPromptCandidates } from "./rankPromptCandidates.js";
-import { errInfo } from "../errInfo.js";
-import { requireRuntimeContext } from "../runtimeContext.js";
-import {
-  getDefaultReviewedDiscoverySources,
-  getReviewedDiscoverySource,
-  listReviewedDiscoverySources,
-} from "./discoveryRegistry.js";
-import type {
-  CuratedSourceLike,
-  GitHubFileSource,
-  PromptCandidate,
-  PromptImportCtx,
-  PromptImportLimits,
-} from "./types.js";
-
-const INDEX_VERSION = 1;
-const EXTRACTOR_VERSION = 2;
-
-interface IndexedFile {
-  sourceFileId: string;
-  owner: string | undefined;
-  repo: string;
-  ref: string;
-  path: string;
-  extension: string;
-  contentHash: string;
-  etag: string | null;
-  sizeBytes: number;
-  licenseSpdx: string;
-  htmlUrl: string;
-  indexedAt: string;
-  lastFetchStatus: string;
-  promptCandidateCount: number;
-  extractorVersion: number;
-}
-
-interface IndexedCandidate extends PromptCandidate {
-  candidateId: string;
-}
-
-interface CacheEntry {
-  source: CuratedSourceLike;
-  files: IndexedFile[];
-  candidates: IndexedCandidate[];
-  refreshedAt: number;
-}
-
-interface IndexCache {
-  version: number;
-  sources: Record<string, CacheEntry>;
-}
-
-interface IndexLimits extends PromptImportLimits {
-  searchLimit: number;
-  ttlMs: number;
-}
-
-function limitsFromCtx(ctx: PromptImportCtx): IndexLimits {
-  const limits = (ctx.config?.limits ?? {}) as Record<string, number>;
-  return {
-    maxFileBytesForPreview: limits.promptImportMaxFileBytes,
-    maxPromptCandidatesPerFile: limits.promptImportMaxCandidatesPerFile,
-    maxPromptCandidatesPerImport: limits.promptImportMaxCandidatesPerImport,
-    fetchTimeoutMs: limits.promptImportFetchTimeoutMs,
-    maxCandidateChars: limits.promptImportMaxCandidateChars,
-    minCandidateChars: limits.promptImportMinCandidateChars,
-    maxSourceCharsScanned: limits.promptImportMaxSourceCharsScanned,
-    maxRepoIndexFiles: limits.promptImportMaxRepoIndexFiles,
-    maxFolderFiles: limits.promptImportMaxFolderFiles ?? 0,
-    maxFolderPreviewFiles: limits.promptImportMaxFolderPreviewFiles ?? 0,
-    searchLimit: limits.promptImportCuratedSearchLimit,
-    ttlMs: limits.promptImportIndexCacheTtlMs,
-  };
-}
-
-function cacheFile(ctx: PromptImportCtx): string {
-  const storage = (ctx.config as { storage?: { promptImportIndexCacheFile?: string } } | undefined)?.storage;
-  return storage?.promptImportIndexCacheFile ?? "";
-}
-
-function sourceFileId(source: CuratedSourceLike, path: string): string {
-  return `github:${source.repo}@${source.defaultRef}:${path}`;
-}
-
-function hashId(...parts: string[]): string {
-  return createHash("sha256").update(parts.join("\0")).digest("hex");
-}
-
-async function readCache(ctx: PromptImportCtx): Promise<IndexCache> {
-  try {
-    const parsed = JSON.parse(await readFile(cacheFile(ctx), "utf8")) as IndexCache;
-    if (parsed.version !== INDEX_VERSION) return { version: INDEX_VERSION, sources: {} };
-    return { version: INDEX_VERSION, sources: parsed.sources || {} };
-  } catch {
-    return { version: INDEX_VERSION, sources: {} };
-  }
-}
-
-async function writeCache(ctx: PromptImportCtx, cache: IndexCache): Promise<void> {
-  const file = cacheFile(ctx);
-  await mkdir(dirname(file), { recursive: true });
-  const tmp = `${file}.${process.pid}.${Date.now()}.tmp`;
-  await writeFile(tmp, JSON.stringify(cache, null, 2));
-  await rename(tmp, file);
-}
-
-function sourceTags(source: CuratedSourceLike, fileSource: GitHubFileSource): string[] {
-  return [
-    ...(fileSource.tags ?? []),
-    `source:${source.id}`,
-    `license:${source.licenseSpdx}`,
-    `trust:${source.trustTier}`,
-    source.requiresAttribution ? "attribution-required" : null,
-  ].filter(Boolean) as string[];
-}
-
-interface IndexedCandidateInput {
-  candidate: PromptCandidate;
-  source: CuratedSourceLike;
-  fileSource: GitHubFileSource;
-  fileIndex: IndexedFile;
-  index: number;
-}
-
-function indexedCandidate({ candidate, source, fileSource, fileIndex, index }: IndexedCandidateInput): IndexedCandidate {
-  const scoreHints = extractGptImageHints(candidate.text);
-  const headingPath = candidate.headingPath || candidate.name || "";
-  const candidateId = hashId(fileIndex.sourceFileId, fileIndex.contentHash, headingPath, String(candidate.ordinal || index + 1));
-  const tags = [...new Set([...(candidate.tags || []), ...sourceTags(source, fileSource)])];
-  return {
-    ...candidate,
-    id: candidateId,
-    candidateId,
-    name: candidate.name,
-    text: candidate.text,
-    textPreview: candidate.textPreview || candidate.text.slice(0, 220),
-    tags,
-    warnings: [...new Set([...(candidate.warnings || []), ...(scoreHints.warnings ?? [])])],
-    source: {
-      kind: "github",
-      owner: source.owner,
-      repo: source.name,
-      ref: source.defaultRef,
-      path: fileSource.path,
-      htmlUrl: fileSource.htmlUrl,
-      sourceId: source.id,
-    },
-    sourceFileId: fileIndex.sourceFileId,
-    headingPath,
-    ordinal: candidate.ordinal || index + 1,
-    promptHash: candidate.promptHash || hashId(candidate.text.trim().toLowerCase()),
-    scoreHints,
-  };
-}
-
-interface IndexSourceResult {
-  source: CuratedSourceLike | null | undefined;
-  indexedFiles: number;
-  candidateCount: number;
-  warnings: string[];
-  entry?: CacheEntry;
-}
-
-async function indexSource(ctx: PromptImportCtx, sourceId: string): Promise<IndexSourceResult> {
-  const source = (getCuratedSource(sourceId) as CuratedSourceLike | undefined) || await getReviewedDiscoverySource(ctx, sourceId);
-  if (!source || source.trustTier === "manual-review") {
-    return { source, indexedFiles: 0, candidateCount: 0, warnings: ["curated-source-unavailable"] };
-  }
-  if (String(source.defaultRef || "").includes("/")) {
-    return { source, indexedFiles: 0, candidateCount: 0, warnings: ["discovery-default-branch-unsupported"] };
-  }
-  if (!Array.isArray(source.allowedPaths) || source.allowedPaths.length === 0) {
-    return { source, indexedFiles: 0, candidateCount: 0, warnings: ["discovery-requires-paths"] };
-  }
-
-  const limits = limitsFromCtx(ctx);
-  const warnings: string[] = [];
-  const files: IndexedFile[] = [];
-  const candidates: IndexedCandidate[] = [];
-  const allowedPaths = source.allowedPaths.slice(0, limits.maxRepoIndexFiles);
-
-  for (const path of allowedPaths) {
-    try {
-      const fileSource = buildGitHubRawFileSource({
-        owner: source.owner ?? "",
-        repo: source.name ?? source.repo,
-        ref: source.defaultRef,
-        path,
-      });
-      const fetched = await fetchGitHubSource(fileSource, limits);
-      const fileIndex: IndexedFile = {
-        sourceFileId: sourceFileId(source, path),
-        owner: source.owner,
-        repo: source.name ?? source.repo,
-        ref: source.defaultRef,
-        path,
-        extension: fileSource.extension ?? "",
-        contentHash: fetched.contentHash,
-        etag: fetched.etag,
-        sizeBytes: fetched.sizeBytes,
-        licenseSpdx: source.licenseSpdx,
-        htmlUrl: fileSource.htmlUrl ?? "",
-        indexedAt: new Date().toISOString(),
-        lastFetchStatus: "ok",
-        promptCandidateCount: 0,
-        extractorVersion: EXTRACTOR_VERSION,
-      };
-      const parsed = parsePromptCandidates({
-        text: fetched.text,
-        filename: path,
-        source: { kind: "github", owner: source.owner, repo: source.name, ref: source.defaultRef, path, htmlUrl: fileSource.htmlUrl },
-        tags: sourceTags(source, fileSource),
-        limits,
-      });
-      const indexed = parsed.map((candidate, index) => indexedCandidate({ candidate, source, fileSource, fileIndex, index }));
-      fileIndex.promptCandidateCount = indexed.length;
-      files.push(fileIndex);
-      candidates.push(...indexed);
-    } catch (error) {
-      const err = errInfo(error);
-      warnings.push(`${path}: ${err.message || "index failed"}`);
-    }
-  }
-
-  return {
-    source,
-    indexedFiles: files.length,
-    candidateCount: candidates.length,
-    warnings,
-    entry: {
-      source,
-      files,
-      candidates,
-      refreshedAt: Date.now(),
-    },
-  };
-}
-
-function isFresh(entry: CacheEntry | undefined, ttlMs: number): boolean {
-  return Boolean(entry?.refreshedAt && Date.now() - entry.refreshedAt < ttlMs);
-}
-
-async function ensureSearchCache(ctx: PromptImportCtx) {
-  const cache = await readCache(ctx);
-  const limits = limitsFromCtx(ctx);
-  const sources = [
-    ...getDefaultSearchSources() as CuratedSourceLike[],
-    ...await getDefaultReviewedDiscoverySources(ctx),
-  ];
-  let changed = false;
-  const warnings: string[] = [];
-
-  for (const source of sources) {
-    if (isFresh(cache.sources[source.id], limits.ttlMs)) continue;
-    const result = await indexSource(ctx, source.id);
-    if (result.entry) {
-      cache.sources[source.id] = result.entry;
-      changed = true;
-    }
-    warnings.push(...result.warnings);
-  }
-  if (changed) await writeCache(ctx, cache);
-  return { cache, warnings };
-}
-
-export async function refreshCuratedSource(ctxIn: PromptImportCtx, sourceId: string) {
-  const ctx = requireRuntimeContext(ctxIn);
-  const cache = await readCache(ctx);
-  const result = await indexSource(ctx, sourceId);
-  if (result.entry) {
-    cache.sources[sourceId] = result.entry;
-    await writeCache(ctx, cache);
-  }
-  return {
-    source: result.source,
-    indexedFiles: result.indexedFiles,
-    candidateCount: result.candidateCount,
-    warnings: result.warnings,
-  };
-}
-
-interface SearchCuratedPromptsOptions {
-  q?: string;
-  sourceIds?: string[];
-  limit?: number;
-}
-
-export async function searchCuratedPrompts(ctxIn: PromptImportCtx, { q = "", sourceIds, limit }: SearchCuratedPromptsOptions = {}) {
-  const ctx = requireRuntimeContext(ctxIn);
-  const { cache, warnings } = await ensureSearchCache(ctx);
-  const limits = limitsFromCtx(ctx);
-  const defaultSources = [
-    ...getDefaultSearchSources() as CuratedSourceLike[],
-    ...await getDefaultReviewedDiscoverySources(ctx),
-  ];
-  const allowedIds = Array.isArray(sourceIds) && sourceIds.length
-    ? new Set(sourceIds)
-    : new Set(defaultSources.map((source) => source.id));
-  const candidates = Object.values(cache.sources)
-    .filter((entry) => allowedIds.has(entry.source.id))
-    .flatMap((entry) => entry.candidates || []);
-  const results = rankPromptCandidates({
-    candidates,
-    query: q,
-    limit: Math.min(Number(limit) || limits.searchLimit, limits.searchLimit),
-  });
-  const sources = [
-    ...listCuratedSources(),
-    ...await listReviewedDiscoverySources(ctx),
-  ];
-  return { results, sources, warnings };
-}
-
-export async function getPromptImportSources(ctxIn: PromptImportCtx | null) {
-  const ctx = ctxIn ? requireRuntimeContext(ctxIn) : null;
-  const reviewed = ctx ? await listReviewedDiscoverySources(ctx) : [];
-  return { sources: [...listCuratedSources(), ...reviewed] };
-}

package/lib/promptImport/rankPromptCandidates.ts

@@ -1,65 +0,0 @@
-import type { PromptCandidate } from "./types.js";
-
-interface RankablePromptCandidate extends Partial<PromptCandidate> {
-  id: string;
-  name: string;
-  text: string;
-  sourceFileId?: string;
-  score?: number;
-}
-
-interface RankPromptCandidatesOptions {
-  candidates: RankablePromptCandidate[];
-  query: string;
-  limit?: number;
-}
-
-function tokenize(value: unknown): string[] {
-  return String(value || "")
-    .toLowerCase()
-    .split(/[^a-z0-9가-힣-]+/i)
-    .map((token) => token.trim())
-    .filter(Boolean);
-}
-
-function includesAny(values: unknown[], terms: string[]): boolean {
-  const haystack = values.map((value) => String(value || "").toLowerCase());
-  return terms.some((term) => haystack.some((value) => value.includes(term)));
-}
-
-export function rankPromptCandidates({ candidates, query, limit }: RankPromptCandidatesOptions): RankablePromptCandidate[] {
-  const terms = tokenize(query);
-  const boundedLimit = Math.max(1, Math.min(Number(limit) || 50, 100));
-  const ranked = candidates.map((candidate) => {
-    const text = String(candidate.text || "").toLowerCase();
-    const name = String(candidate.name || "").toLowerCase();
-    const tags = Array.isArray(candidate.tags) ? candidate.tags : [];
-    const hints = candidate.scoreHints || {};
-    const hintValues: unknown[] = [
-      ...(hints.modelHints || []),
-      ...(hints.generationSurfaceHints || []),
-      ...(hints.taskHints || []),
-      ...(hints.sizeHints || []),
-      ...(hints.qualityHints || []),
-    ];
-    let score = 0;
-
-    if (terms.length === 0) score += 1;
-    for (const term of terms) {
-      if (name.includes(term)) score += 18;
-      if (includesAny(tags, [term])) score += 12;
-      if (includesAny(hintValues, [term])) score += 14;
-      if (text.includes(term)) score += 5;
-      if (String(candidate.sourceFileId || "").toLowerCase().includes(term)) score += 4;
-    }
-    if (tags.some((tag) => tag === "trust:curated")) score += 5;
-    if (candidate.warnings?.length) score -= candidate.warnings.length * 3;
-
-    return { ...candidate, score };
-  });
-
-  return ranked
-    .filter((candidate) => terms.length === 0 || (candidate.score ?? 0) > 0)
-    .sort((a, b) => (b.score ?? 0) - (a.score ?? 0) || String(a.name).localeCompare(String(b.name)))
-    .slice(0, boundedLimit);
-}

package/lib/promptImport/types.ts

@@ -1,103 +0,0 @@
-import type { RouteRuntimeContext } from "../runtimeContext.js";
-
-export type PromptImportCtx = RouteRuntimeContext;
-
-export interface PromptImportLimits {
-  maxFileBytesForPreview: number;
-  maxPromptCandidatesPerFile: number;
-  maxPromptCandidatesPerImport: number;
-  fetchTimeoutMs: number;
-  maxCandidateChars: number;
-  minCandidateChars: number;
-  maxSourceCharsScanned: number;
-  maxRepoIndexFiles?: number;
-  searchLimit?: number;
-  ttlMs?: number;
-  maxFolderFiles?: number;
-  maxFolderPreviewFiles?: number;
-}
-
-export interface PromptCandidateSource {
-  kind: string;
-  owner?: string;
-  repo?: string;
-  ref?: string;
-  path?: string;
-  htmlUrl?: string;
-  sourceId?: string;
-  filename?: string;
-}
-
-export interface PromptCandidateScoreHints {
-  modelHints?: string[];
-  generationSurfaceHints?: string[];
-  taskHints?: string[];
-  sizeHints?: string[];
-  qualityHints?: string[];
-  warnings?: string[];
-}
-
-export interface PromptCandidate {
-  id: string;
-  candidateId?: string;
-  name: string;
-  text: string;
-  textPreview: string;
-  tags: string[];
-  warnings: string[];
-  source: PromptCandidateSource;
-  sourceFileId?: string;
-  headingPath: string | null;
-  ordinal: number;
-  promptHash: string;
-  scoreHints: PromptCandidateScoreHints;
-}
-
-export interface CuratedSourceLike {
-  id: string;
-  repo: string;
-  owner?: string;
-  name?: string;
-  displayName?: string;
-  defaultRef: string;
-  allowedPaths: string[];
-  extensions: string[];
-  sourceType?: string;
-  licenseSpdx: string;
-  requiresAttribution?: boolean;
-  trustTier: string;
-  lastVerifiedAt?: string | null;
-  notes?: string;
-  searchSeeds?: string[];
-  defaultSearch?: boolean;
-}
-
-export interface GitHubFileSource {
-  kind?: string;
-  owner?: string;
-  repo?: string;
-  ref?: string;
-  path?: string;
-  extension?: string;
-  htmlUrl?: string;
-  rawUrl: string;
-  tags?: string[];
-}
-
-export interface DiscoveryRepo {
-  full_name?: string;
-  description?: string | null;
-  topics?: string[];
-  pushed_at?: string | null;
-  stargazers_count?: number;
-  forks_count?: number;
-  open_issues_count?: number;
-  updated_at?: string | null;
-  license?: { spdx_id?: string | null } | null;
-  archived?: boolean;
-  disabled?: boolean;
-  fork?: boolean;
-  default_branch?: string | null;
-  html_url?: string | null;
-  language?: string | null;
-}

package/lib/promptSafetyPolicy.ts

@@ -1,5 +0,0 @@
-export const SAFETY_INTENT_POLICY = [
-  "* [Level of Intent to Sexual Exploitation]: Zero",
-  "* [Level of Intent to Sexual Commodification]: Zero",
-  "* [Judged by Appearance Alone]: Forbidden",
-].join("\n");

package/lib/providerOptions.ts

@@ -1,56 +0,0 @@
-import type { RuntimeContext } from "./runtimeContext.js";
-import { normalizeImageModel, normalizeReasoningEffort, normalizeGrokImageModel } from "./imageModels.js";
-
-export function resolveProviderOptions(ctx: RuntimeContext | null | undefined, {
-  provider = "oauth",
-  rawModel,
-  rawReasoningEffort,
-  rawSize = "1024x1024",
-  rawWebSearchEnabled = true,
-  searchMode = "on",
-}: any = {}) {
-  if (provider === "grok") {
-    const grokCfg: { defaultImageModel?: string } = (ctx?.config as any)?.grokProvider || {};
-    const modelInput = rawModel || grokCfg.defaultImageModel;
-    const grokModelCheck = normalizeGrokImageModel(modelInput);
-    if (grokModelCheck.error) return { error: grokModelCheck.error, code: grokModelCheck.code, status: grokModelCheck.status };
-    return {
-      provider: "grok" as const,
-      model: grokModelCheck.model,
-      reasoningEffort: "none",
-      size: rawSize,
-      webSearchEnabled: true,
-    };
-  }
-
-  const activeProvider = provider === "api" ? "api" : "oauth";
-  const apiConfig: { defaultImageModel?: string; defaultReasoningEffort?: string; defaultSize?: string; allowWebSearch?: boolean } = (ctx?.config as { apiProvider?: any })?.apiProvider || {};
-  const modelInput = activeProvider === "api"
-    ? (rawModel || apiConfig.defaultImageModel || "gpt-5.4-mini")
-    : rawModel;
-  const modelCheck = normalizeImageModel(ctx, modelInput);
-  if (modelCheck.error) return { error: modelCheck.error, code: modelCheck.code, status: modelCheck.status };
-
-  const reasoningInput = activeProvider === "api"
-    ? (rawReasoningEffort || apiConfig.defaultReasoningEffort || "low")
-    : rawReasoningEffort;
-  const reasoningCheck = normalizeReasoningEffort(ctx, reasoningInput);
-  if (reasoningCheck.error) {
-    return { error: reasoningCheck.error, code: reasoningCheck.code, status: reasoningCheck.status };
-  }
-
-  const size = activeProvider === "api" && (typeof rawSize !== "string" || rawSize.length === 0)
-    ? (apiConfig.defaultSize || "1024x1024")
-    : rawSize;
-  const webSearchEnabled = activeProvider === "api"
-    ? apiConfig.allowWebSearch !== false && rawWebSearchEnabled !== false && searchMode !== "off"
-    : rawWebSearchEnabled !== false && searchMode !== "off";
-
-  return {
-    provider: activeProvider,
-    model: modelCheck.model,
-    reasoningEffort: reasoningCheck.effort,
-    size,
-    webSearchEnabled,
-  };
-}

package/lib/referenceImageCompress.ts

@@ -1,84 +0,0 @@
-import sharp from "sharp";
-
-const DEFAULT_MAX_B64_BYTES = 6 * 1024 * 1024;
-const DEFAULT_MAX_EDGE = 3840;
-const DEFAULT_QUALITY_LADDER = [85, 75, 65, 55];
-const FALLBACK_MAX_EDGE = 2048;
-const FALLBACK_QUALITY_LADDER = [75, 65, 55];
-
-function stripDataUrlPrefix(value: unknown) {
-  return String(value || "").replace(/^data:[^;]+;base64,/, "");
-}
-
-function toBase64(buffer: Buffer) {
-  return buffer.toString("base64");
-}
-
-async function encodeJpegWithinBudget(input: Buffer, {
-  maxB64Bytes,
-  maxEdge,
-  qualityLadder,
-}: { maxB64Bytes: number; maxEdge: number; qualityLadder: number[] }) {
-  for (const quality of qualityLadder) {
-    const out = await sharp(input, { failOn: "none" })
-      .rotate()
-      .resize({
-        width: maxEdge,
-        height: maxEdge,
-        fit: "inside",
-        withoutEnlargement: true,
-      })
-      .flatten({ background: "#ffffff" })
-      .jpeg({ quality, progressive: true })
-      .toBuffer();
-    const b64 = toBase64(out);
-    if (b64.length <= maxB64Bytes) return { b64, compressed: true, quality, maxEdge };
-  }
-  return null;
-}
-
-interface CompressOptions {
-  maxB64Bytes?: number;
-  maxEdge?: number;
-  qualityLadder?: number[];
-  fallbackMaxEdge?: number;
-  fallbackQualityLadder?: number[];
-  force?: boolean;
-}
-
-export async function compressReferenceB64ForOAuth(imageB64: string | undefined | null, options: CompressOptions = {}) {
-  const rawB64 = stripDataUrlPrefix(imageB64);
-  const maxB64Bytes = options.maxB64Bytes ?? DEFAULT_MAX_B64_BYTES;
-  const maxEdge = options.maxEdge ?? DEFAULT_MAX_EDGE;
-  const qualityLadder = options.qualityLadder ?? DEFAULT_QUALITY_LADDER;
-  if (!rawB64) return { b64: rawB64, compressed: false, inputBytes: 0, outputBytes: 0 };
-
-  const input = Buffer.from(rawB64, "base64");
-  const inputBytes = rawB64.length;
-  if (!options.force && inputBytes <= maxB64Bytes) {
-    return { b64: rawB64, compressed: false, inputBytes, outputBytes: inputBytes };
-  }
-
-  const primary = await encodeJpegWithinBudget(input, {
-    maxB64Bytes,
-    maxEdge,
-    qualityLadder,
-  });
-  if (primary) {
-    return { ...primary, inputBytes, outputBytes: primary.b64.length };
-  }
-
-  const fallback = await encodeJpegWithinBudget(input, {
-    maxB64Bytes,
-    maxEdge: options.fallbackMaxEdge ?? FALLBACK_MAX_EDGE,
-    qualityLadder: options.fallbackQualityLadder ?? FALLBACK_QUALITY_LADDER,
-  });
-  if (fallback) {
-    return { ...fallback, inputBytes, outputBytes: fallback.b64.length };
-  }
-
-  const err = new Error(`Reference image remains above ${maxB64Bytes} base64 bytes after compression`) as Error & { code?: string; status?: number };
-  err.code = "REF_TOO_LARGE";
-  err.status = 400;
-  throw err;
-}