@qvac/sdk 0.8.0 → 1.0.0

package/dist/schemas/model-types.d.ts

@@ -1,183 +0,0 @@
-import { z } from "zod";
-/**
- * Canonical model type values for internal SDK use.
- * Format: `engine-usecase` (e.g., "llamacpp-completion")
- * Use dot-accessor syntax: `ModelType.llamacppCompletion`
- */
-export declare const ModelType: {
-    readonly llamacppCompletion: "llamacpp-completion";
-    readonly whispercppTranscription: "whispercpp-transcription";
-    readonly llamacppEmbedding: "llamacpp-embedding";
-    readonly nmtcppTranslation: "nmtcpp-translation";
-    readonly onnxTts: "onnx-tts";
-    readonly parakeetTranscription: "parakeet-transcription";
-    readonly onnxOcr: "onnx-ocr";
-};
-/**
- * Alias mappings for backward compatibility.
- * Maps old names to canonical values.
- */
-export declare const ModelTypeAliases: {
-    readonly llm: "llamacpp-completion";
-    readonly whisper: "whispercpp-transcription";
-    readonly embeddings: "llamacpp-embedding";
-    readonly nmt: "nmtcpp-translation";
-    readonly parakeet: "parakeet-transcription";
-    readonly tts: "onnx-tts";
-    readonly ocr: "onnx-ocr";
-};
-export type CanonicalModelType = (typeof ModelType)[keyof typeof ModelType];
-export type AliasKey = keyof typeof ModelTypeAliases;
-export type ModelTypeInput = CanonicalModelType | AliasKey;
-/**
- * All valid model types: canonical names + aliases.
- *
- * Canonical names follow `engine-usecase` format (e.g., "llamacpp-completion").
- * Aliases resolve to canonical names for backward compatibility.
- *
- * @example
- * ```typescript
- * // Using alias (backward compatible)
- * loadModel({ modelSrc: "...", modelType: MODEL_TYPES.nmt });
- * // MODEL_TYPES.nmt resolves to "nmtcpp-translation"
- *
- * // Using canonical name directly
- * loadModel({ modelSrc: "...", modelType: MODEL_TYPES.nmtcppTranslation });
- * ```
- */
-export declare const PUBLIC_MODEL_TYPES: {
-    readonly llm: "llamacpp-completion";
-    readonly whisper: "whispercpp-transcription";
-    readonly embeddings: "llamacpp-embedding";
-    readonly nmt: "nmtcpp-translation";
-    readonly parakeet: "parakeet-transcription";
-    readonly tts: "onnx-tts";
-    readonly ocr: "onnx-ocr";
-    readonly llamacppCompletion: "llamacpp-completion";
-    readonly whispercppTranscription: "whispercpp-transcription";
-    readonly llamacppEmbedding: "llamacpp-embedding";
-    readonly nmtcppTranslation: "nmtcpp-translation";
-    readonly onnxTts: "onnx-tts";
-    readonly parakeetTranscription: "parakeet-transcription";
-    readonly onnxOcr: "onnx-ocr";
-};
-/** Schema accepting both canonical and alias model type inputs */
-export declare const modelTypeInputSchema: z.ZodEnum<{
-    "llamacpp-completion": "llamacpp-completion";
-    "whispercpp-transcription": "whispercpp-transcription";
-    "llamacpp-embedding": "llamacpp-embedding";
-    "nmtcpp-translation": "nmtcpp-translation";
-    "onnx-tts": "onnx-tts";
-    "parakeet-transcription": "parakeet-transcription";
-    "onnx-ocr": "onnx-ocr";
-    llm: "llm";
-    whisper: "whisper";
-    embeddings: "embeddings";
-    nmt: "nmt";
-    parakeet: "parakeet";
-    tts: "tts";
-    ocr: "ocr";
-}>;
-/** Schema that transforms input to canonical model type */
-export declare const modelTypeSchema: z.ZodPipe<z.ZodEnum<{
-    "llamacpp-completion": "llamacpp-completion";
-    "whispercpp-transcription": "whispercpp-transcription";
-    "llamacpp-embedding": "llamacpp-embedding";
-    "nmtcpp-translation": "nmtcpp-translation";
-    "onnx-tts": "onnx-tts";
-    "parakeet-transcription": "parakeet-transcription";
-    "onnx-ocr": "onnx-ocr";
-    llm: "llm";
-    whisper: "whisper";
-    embeddings: "embeddings";
-    nmt: "nmt";
-    parakeet: "parakeet";
-    tts: "tts";
-    ocr: "ocr";
-}>, z.ZodTransform<"llamacpp-completion" | "whispercpp-transcription" | "llamacpp-embedding" | "nmtcpp-translation" | "onnx-tts" | "parakeet-transcription" | "onnx-ocr", "llamacpp-completion" | "whispercpp-transcription" | "llamacpp-embedding" | "nmtcpp-translation" | "onnx-tts" | "parakeet-transcription" | "onnx-ocr" | "llm" | "whisper" | "embeddings" | "nmt" | "parakeet" | "tts" | "ocr">>;
-/**
- * Normalize model type input to canonical form.
- * Custom plugin types (not in built-ins) are returned as-is.
- */
-export declare function normalizeModelType(input: string): string;
-/**
- * Type guard to check if a string is a canonical (built-in) model type.
- * Returns false for custom plugin types.
- */
-export declare function isCanonicalModelType(input: string): input is CanonicalModelType;
-/**
- * Check if input is a built-in alias (not canonical or custom).
- * Returns false for custom plugin types.
- */
-export declare function isModelTypeAlias(input: string): boolean;
-/**
- * LLM/Completion model type schema.
- * - Alias: `"llm"` → resolves to `"llamacpp-completion"`
- * - Canonical: `"llamacpp-completion"`
- */
-export declare const llmModelTypeSchema: z.ZodEnum<{
-    "llamacpp-completion": "llamacpp-completion";
-    llm: "llm";
-}>;
-export type LlmModelTypeInput = z.infer<typeof llmModelTypeSchema>;
-/**
- * Whisper/Transcription model type schema.
- * - Alias: `"whisper"` → resolves to `"whispercpp-transcription"`
- * - Canonical: `"whispercpp-transcription"`
- */
-export declare const whisperModelTypeSchema: z.ZodEnum<{
-    "whispercpp-transcription": "whispercpp-transcription";
-    whisper: "whisper";
-}>;
-export type WhisperModelTypeInput = z.infer<typeof whisperModelTypeSchema>;
-/**
- * Parakeet/Transcription model type schema.
- * - Alias: `"parakeet"` → resolves to `"parakeet-transcription"`
- * - Canonical: `"parakeet-transcription"`
- */
-export declare const parakeetModelTypeSchema: z.ZodEnum<{
-    "parakeet-transcription": "parakeet-transcription";
-    parakeet: "parakeet";
-}>;
-export type ParakeetModelTypeInput = z.infer<typeof parakeetModelTypeSchema>;
-/**
- * Embeddings model type schema.
- * - Alias: `"embeddings"` → resolves to `"llamacpp-embedding"`
- * - Canonical: `"llamacpp-embedding"`
- */
-export declare const embeddingsModelTypeSchema: z.ZodEnum<{
-    "llamacpp-embedding": "llamacpp-embedding";
-    embeddings: "embeddings";
-}>;
-export type EmbeddingsModelTypeInput = z.infer<typeof embeddingsModelTypeSchema>;
-/**
- * NMT/Translation model type schema.
- * - Alias: `"nmt"` → resolves to `"nmtcpp-translation"`
- * - Canonical: `"nmtcpp-translation"`
- */
-export declare const nmtModelTypeSchema: z.ZodEnum<{
-    "nmtcpp-translation": "nmtcpp-translation";
-    nmt: "nmt";
-}>;
-export type NmtModelTypeInput = z.infer<typeof nmtModelTypeSchema>;
-/**
- * TTS model type schema.
- * - Alias: `"tts"` → resolves to `"onnx-tts"`
- * - Canonical: `"onnx-tts"`
- */
-export declare const ttsModelTypeSchema: z.ZodEnum<{
-    "onnx-tts": "onnx-tts";
-    tts: "tts";
-}>;
-export type TtsModelTypeInput = z.infer<typeof ttsModelTypeSchema>;
-/**
- * OCR model type schema.
- * - Alias: `"ocr"` → resolves to `"onnx-ocr"`
- * - Canonical: `"onnx-ocr"`
- */
-export declare const ocrModelTypeSchema: z.ZodEnum<{
-    "onnx-ocr": "onnx-ocr";
-    ocr: "ocr";
-}>;
-export type OcrModelTypeInput = z.infer<typeof ocrModelTypeSchema>;
-//# sourceMappingURL=model-types.d.ts.map

package/dist/schemas/model-types.js

@@ -1,168 +0,0 @@
-import { z } from "zod";
-// === INTERNAL: Canonical types (used in SDK code) ===
-/**
- * Canonical model type values for internal SDK use.
- * Format: `engine-usecase` (e.g., "llamacpp-completion")
- * Use dot-accessor syntax: `ModelType.llamacppCompletion`
- */
-export const ModelType = {
-    llamacppCompletion: "llamacpp-completion",
-    whispercppTranscription: "whispercpp-transcription",
-    llamacppEmbedding: "llamacpp-embedding",
-    nmtcppTranslation: "nmtcpp-translation",
-    onnxTts: "onnx-tts",
-    parakeetTranscription: "parakeet-transcription",
-    onnxOcr: "onnx-ocr",
-};
-// === INTERNAL: Alias keys (backward compat names) ===
-const AliasKeys = {
-    llm: "llm",
-    whisper: "whisper",
-    embeddings: "embeddings",
-    nmt: "nmt",
-    parakeet: "parakeet",
-    tts: "tts",
-    ocr: "ocr",
-};
-// === INTERNAL: Aliases (backward compat mapping) ===
-/**
- * Alias mappings for backward compatibility.
- * Maps old names to canonical values.
- */
-export const ModelTypeAliases = {
-    [AliasKeys.llm]: ModelType.llamacppCompletion,
-    [AliasKeys.whisper]: ModelType.whispercppTranscription,
-    [AliasKeys.embeddings]: ModelType.llamacppEmbedding,
-    [AliasKeys.nmt]: ModelType.nmtcppTranslation,
-    [AliasKeys.parakeet]: ModelType.parakeetTranscription,
-    [AliasKeys.tts]: ModelType.onnxTts,
-    [AliasKeys.ocr]: ModelType.onnxOcr,
-};
-// Set of canonical values for quick lookup
-const canonicalValuesSet = new Set(Object.values(ModelType));
-// === PUBLIC: Combined (exported via index.ts as MODEL_TYPES) ===
-/**
- * All valid model types: canonical names + aliases.
- *
- * Canonical names follow `engine-usecase` format (e.g., "llamacpp-completion").
- * Aliases resolve to canonical names for backward compatibility.
- *
- * @example
- * ```typescript
- * // Using alias (backward compatible)
- * loadModel({ modelSrc: "...", modelType: MODEL_TYPES.nmt });
- * // MODEL_TYPES.nmt resolves to "nmtcpp-translation"
- *
- * // Using canonical name directly
- * loadModel({ modelSrc: "...", modelType: MODEL_TYPES.nmtcppTranslation });
- * ```
- */
-export const PUBLIC_MODEL_TYPES = {
-    ...ModelType,
-    ...ModelTypeAliases,
-};
-// === ZOD SCHEMAS ===
-// Derive input values from objects - no string repetition
-const inputValues = [
-    ...Object.values(ModelType),
-    ...Object.keys(ModelTypeAliases),
-];
-/** Schema accepting both canonical and alias model type inputs */
-export const modelTypeInputSchema = z.enum(inputValues);
-/** Schema that transforms input to canonical model type */
-export const modelTypeSchema = modelTypeInputSchema.transform((val) => {
-    // If already canonical, return as-is
-    if (canonicalValuesSet.has(val)) {
-        return val;
-    }
-    // Otherwise, look up in aliases
-    return ModelTypeAliases[val];
-});
-/**
- * Normalize model type input to canonical form.
- * Custom plugin types (not in built-ins) are returned as-is.
- */
-export function normalizeModelType(input) {
-    // If already canonical, return as-is
-    if (canonicalValuesSet.has(input)) {
-        return input;
-    }
-    // If it's an alias, normalize to canonical
-    if (input in ModelTypeAliases) {
-        return ModelTypeAliases[input];
-    }
-    // Custom plugin type - return as-is
-    return input;
-}
-/**
- * Type guard to check if a string is a canonical (built-in) model type.
- * Returns false for custom plugin types.
- */
-export function isCanonicalModelType(input) {
-    return canonicalValuesSet.has(input);
-}
-/**
- * Check if input is a built-in alias (not canonical or custom).
- * Returns false for custom plugin types.
- */
-export function isModelTypeAlias(input) {
-    return input in ModelTypeAliases;
-}
-// === PER-MODEL-TYPE SCHEMAS (for discriminated unions) ===
-// Extracted from root enum - no value duplication
-/**
- * LLM/Completion model type schema.
- * - Alias: `"llm"` → resolves to `"llamacpp-completion"`
- * - Canonical: `"llamacpp-completion"`
- */
-export const llmModelTypeSchema = modelTypeInputSchema
-    .extract([AliasKeys.llm, ModelType.llamacppCompletion])
-    .describe('LLM model type: "llm" (alias) or "llamacpp-completion" (canonical)');
-/**
- * Whisper/Transcription model type schema.
- * - Alias: `"whisper"` → resolves to `"whispercpp-transcription"`
- * - Canonical: `"whispercpp-transcription"`
- */
-export const whisperModelTypeSchema = modelTypeInputSchema
-    .extract([AliasKeys.whisper, ModelType.whispercppTranscription])
-    .describe('Whisper model type: "whisper" (alias) or "whispercpp-transcription" (canonical)');
-/**
- * Parakeet/Transcription model type schema.
- * - Alias: `"parakeet"` → resolves to `"parakeet-transcription"`
- * - Canonical: `"parakeet-transcription"`
- */
-export const parakeetModelTypeSchema = modelTypeInputSchema
-    .extract([AliasKeys.parakeet, ModelType.parakeetTranscription])
-    .describe('Parakeet model type: "parakeet" (alias) or "parakeet-transcription" (canonical)');
-/**
- * Embeddings model type schema.
- * - Alias: `"embeddings"` → resolves to `"llamacpp-embedding"`
- * - Canonical: `"llamacpp-embedding"`
- */
-export const embeddingsModelTypeSchema = modelTypeInputSchema
-    .extract([AliasKeys.embeddings, ModelType.llamacppEmbedding])
-    .describe('Embeddings model type: "embeddings" (alias) or "llamacpp-embedding" (canonical)');
-/**
- * NMT/Translation model type schema.
- * - Alias: `"nmt"` → resolves to `"nmtcpp-translation"`
- * - Canonical: `"nmtcpp-translation"`
- */
-export const nmtModelTypeSchema = modelTypeInputSchema
-    .extract([AliasKeys.nmt, ModelType.nmtcppTranslation])
-    .describe('NMT model type: "nmt" (alias) or "nmtcpp-translation" (canonical)');
-/**
- * TTS model type schema.
- * - Alias: `"tts"` → resolves to `"onnx-tts"`
- * - Canonical: `"onnx-tts"`
- */
-export const ttsModelTypeSchema = modelTypeInputSchema
-    .extract([AliasKeys.tts, ModelType.onnxTts])
-    .describe('TTS model type: "tts" (alias) or "onnx-tts" (canonical)');
-/**
- * OCR model type schema.
- * - Alias: `"ocr"` → resolves to `"onnx-ocr"`
- * - Canonical: `"onnx-ocr"`
- */
-export const ocrModelTypeSchema = modelTypeInputSchema
-    .extract([AliasKeys.ocr, ModelType.onnxOcr])
-    .describe('OCR model type: "ocr" (alias) or "onnx-ocr" (canonical)');

package/dist/schemas/ocr.d.ts

@@ -1,125 +0,0 @@
-import { z } from "zod";
-export declare const ocrConfigSchema: z.ZodObject<{
-    langList: z.ZodOptional<z.ZodArray<z.ZodString>>;
-    useGPU: z.ZodOptional<z.ZodBoolean>;
-    timeout: z.ZodOptional<z.ZodNumber>;
-    pipelineMode: z.ZodOptional<z.ZodEnum<{
-        easyocr: "easyocr";
-        doctr: "doctr";
-    }>>;
-    magRatio: z.ZodOptional<z.ZodNumber>;
-    defaultRotationAngles: z.ZodOptional<z.ZodArray<z.ZodNumber>>;
-    contrastRetry: z.ZodOptional<z.ZodBoolean>;
-    lowConfidenceThreshold: z.ZodOptional<z.ZodNumber>;
-    recognizerBatchSize: z.ZodOptional<z.ZodNumber>;
-    decodingMethod: z.ZodOptional<z.ZodEnum<{
-        attention: "attention";
-        ctc: "ctc";
-    }>>;
-    straightenPages: z.ZodOptional<z.ZodBoolean>;
-    detectorModelSrc: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodObject<{
-        src: z.ZodString;
-        name: z.ZodOptional<z.ZodString>;
-        modelId: z.ZodOptional<z.ZodString>;
-        registryPath: z.ZodOptional<z.ZodString>;
-        registrySource: z.ZodOptional<z.ZodString>;
-        blobCoreKey: z.ZodOptional<z.ZodString>;
-        blobIndex: z.ZodOptional<z.ZodNumber>;
-        engine: z.ZodOptional<z.ZodString>;
-        expectedSize: z.ZodOptional<z.ZodNumber>;
-        sha256Checksum: z.ZodOptional<z.ZodString>;
-        addon: z.ZodOptional<z.ZodUnion<readonly [z.ZodEnum<{
-            "llamacpp-completion": "llamacpp-completion";
-            "whispercpp-transcription": "whispercpp-transcription";
-            "llamacpp-embedding": "llamacpp-embedding";
-            "nmtcpp-translation": "nmtcpp-translation";
-            "onnx-tts": "onnx-tts";
-            "parakeet-transcription": "parakeet-transcription";
-            "onnx-ocr": "onnx-ocr";
-            llm: "llm";
-            whisper: "whisper";
-            embeddings: "embeddings";
-            nmt: "nmt";
-            parakeet: "parakeet";
-            tts: "tts";
-            ocr: "ocr";
-        }>, z.ZodLiteral<"vad">]>>;
-    }, z.core.$strip>]>>;
-}, z.core.$strip>;
-export declare const imageInputSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
-    type: z.ZodLiteral<"base64">;
-    value: z.ZodString;
-}, z.core.$strip>, z.ZodObject<{
-    type: z.ZodLiteral<"filePath">;
-    value: z.ZodString;
-}, z.core.$strip>], "type">;
-export declare const ocrOptionsSchema: z.ZodObject<{
-    paragraph: z.ZodOptional<z.ZodBoolean>;
-}, z.core.$strip>;
-export declare const ocrParamsSchema: z.ZodObject<{
-    modelId: z.ZodString;
-    image: z.ZodDiscriminatedUnion<[z.ZodObject<{
-        type: z.ZodLiteral<"base64">;
-        value: z.ZodString;
-    }, z.core.$strip>, z.ZodObject<{
-        type: z.ZodLiteral<"filePath">;
-        value: z.ZodString;
-    }, z.core.$strip>], "type">;
-    options: z.ZodOptional<z.ZodObject<{
-        paragraph: z.ZodOptional<z.ZodBoolean>;
-    }, z.core.$strip>>;
-}, z.core.$strip>;
-export declare const ocrStreamRequestSchema: z.ZodObject<{
-    modelId: z.ZodString;
-    image: z.ZodDiscriminatedUnion<[z.ZodObject<{
-        type: z.ZodLiteral<"base64">;
-        value: z.ZodString;
-    }, z.core.$strip>, z.ZodObject<{
-        type: z.ZodLiteral<"filePath">;
-        value: z.ZodString;
-    }, z.core.$strip>], "type">;
-    options: z.ZodOptional<z.ZodObject<{
-        paragraph: z.ZodOptional<z.ZodBoolean>;
-    }, z.core.$strip>>;
-    type: z.ZodLiteral<"ocrStream">;
-}, z.core.$strip>;
-export declare const ocrTextBlockSchema: z.ZodObject<{
-    text: z.ZodString;
-    bbox: z.ZodOptional<z.ZodTuple<[z.ZodNumber, z.ZodNumber, z.ZodNumber, z.ZodNumber], null>>;
-    confidence: z.ZodOptional<z.ZodNumber>;
-}, z.core.$strip>;
-export declare const ocrStatsSchema: z.ZodObject<{
-    detectionTime: z.ZodOptional<z.ZodNumber>;
-    recognitionTime: z.ZodOptional<z.ZodNumber>;
-    totalTime: z.ZodOptional<z.ZodNumber>;
-}, z.core.$strip>;
-export declare const ocrStreamResponseSchema: z.ZodObject<{
-    type: z.ZodLiteral<"ocrStream">;
-    blocks: z.ZodOptional<z.ZodArray<z.ZodObject<{
-        text: z.ZodString;
-        bbox: z.ZodOptional<z.ZodTuple<[z.ZodNumber, z.ZodNumber, z.ZodNumber, z.ZodNumber], null>>;
-        confidence: z.ZodOptional<z.ZodNumber>;
-    }, z.core.$strip>>>;
-    done: z.ZodOptional<z.ZodBoolean>;
-    error: z.ZodOptional<z.ZodString>;
-    stats: z.ZodOptional<z.ZodObject<{
-        detectionTime: z.ZodOptional<z.ZodNumber>;
-        recognitionTime: z.ZodOptional<z.ZodNumber>;
-        totalTime: z.ZodOptional<z.ZodNumber>;
-    }, z.core.$strip>>;
-}, z.core.$strip>;
-export type OCRConfig = z.infer<typeof ocrConfigSchema>;
-export type ImageInput = z.infer<typeof imageInputSchema>;
-export type OCROptions = z.infer<typeof ocrOptionsSchema>;
-export type OCRParams = z.infer<typeof ocrParamsSchema>;
-export type OCRClientParams = {
-    modelId: string;
-    image: string | Buffer;
-    options?: OCROptions;
-    stream?: boolean;
-};
-export type OCRStreamRequest = z.infer<typeof ocrStreamRequestSchema>;
-export type OCRStreamResponse = z.infer<typeof ocrStreamResponseSchema>;
-export type OCRTextBlock = z.infer<typeof ocrTextBlockSchema>;
-export type OCRStats = z.infer<typeof ocrStatsSchema>;
-//# sourceMappingURL=ocr.d.ts.map

package/dist/schemas/ocr.js

@@ -1,57 +0,0 @@
-import { z } from "zod";
-import { modelSrcInputSchema } from "./model-src-utils.js";
-// Model config
-export const ocrConfigSchema = z.object({
-    langList: z.array(z.string()).optional(),
-    useGPU: z.boolean().optional(),
-    timeout: z.number().optional(),
-    pipelineMode: z.enum(["easyocr", "doctr"]).optional(),
-    magRatio: z.number().optional(),
-    defaultRotationAngles: z.array(z.number()).optional(),
-    contrastRetry: z.boolean().optional(),
-    lowConfidenceThreshold: z.number().optional(),
-    recognizerBatchSize: z.number().optional(),
-    decodingMethod: z.enum(["ctc", "attention"]).optional(),
-    straightenPages: z.boolean().optional(),
-    detectorModelSrc: modelSrcInputSchema.optional(),
-});
-// Image input types
-export const imageInputSchema = z.discriminatedUnion("type", [
-    z.object({
-        type: z.literal("base64"),
-        value: z.string(),
-    }),
-    z.object({
-        type: z.literal("filePath"),
-        value: z.string(),
-    }),
-]);
-// OCR options
-export const ocrOptionsSchema = z.object({
-    paragraph: z.boolean().optional(),
-});
-export const ocrParamsSchema = z.object({
-    modelId: z.string(),
-    image: imageInputSchema,
-    options: ocrOptionsSchema.optional(),
-});
-export const ocrStreamRequestSchema = ocrParamsSchema.extend({
-    type: z.literal("ocrStream"),
-});
-export const ocrTextBlockSchema = z.object({
-    text: z.string(),
-    bbox: z.tuple([z.number(), z.number(), z.number(), z.number()]).optional(),
-    confidence: z.number().optional(),
-});
-export const ocrStatsSchema = z.object({
-    detectionTime: z.number().optional(),
-    recognitionTime: z.number().optional(),
-    totalTime: z.number().optional(),
-});
-export const ocrStreamResponseSchema = z.object({
-    type: z.literal("ocrStream"),
-    blocks: z.array(ocrTextBlockSchema).optional(),
-    done: z.boolean().optional(),
-    error: z.string().optional(),
-    stats: ocrStatsSchema.optional(),
-});

package/dist/schemas/path-validation.d.ts

@@ -1,10 +0,0 @@
-import { z } from "zod";
-/**
- * Zod refinement for path components that get joined to a base directory.
- * Rejects strings containing traversal sequences (.., null bytes).
- *
- * DO NOT apply to fields that accept absolute user paths (e.g. audio, image,
- * model, or attachment paths).
- */
-export declare const safePathComponent: z.ZodString;
-//# sourceMappingURL=path-validation.d.ts.map

package/dist/schemas/path-validation.js

@@ -1,22 +0,0 @@
-import { z } from "zod";
-/**
- * Zod refinement for path components that get joined to a base directory.
- * Rejects strings containing traversal sequences (.., null bytes).
- *
- * DO NOT apply to fields that accept absolute user paths (e.g. audio, image,
- * model, or attachment paths).
- */
-export const safePathComponent = z.string().refine((s) => {
-    // Reject literal traversal
-    if (s.includes(".."))
-        return false;
-    // Reject null bytes (literal and URL-encoded)
-    if (s.includes("\0") || s.toLowerCase().includes("%00"))
-        return false;
-    // Reject URL-encoded traversal (%2e = ".", %2f = "/", %5c = "\")
-    if (/%2e/i.test(s))
-        return false;
-    return true;
-}, {
-    message: "Path component must not contain traversal sequences ('..', '%2e'), null bytes, or '%00'",
-});