Skip to content

Open-source LLM knowledge platform: turn raw documents into a queryable RAG, an autonomous reasoning agent, and a self-maintaining Wiki.

fix: store inline images and apply AI budget in document order (#4121)

jacentsao538437e42932
diff --git a/internal/application/service/knowledge_create.go b/internal/application/service/knowledge_create.go
index 413dce685..33adbfc71 100644
--- a/internal/application/service/knowledge_create.go
+++ b/internal/application/service/knowledge_create.go
@@ -3,6 +3,7 @@ package service
import (
"context"
"encoding/json"
+ "errors"
"fmt"
"mime/multipart"
"net/url"
@@ -16,6 +17,7 @@ import (
"github.com/Tencent/WeKnora/internal/logger"
"github.com/Tencent/WeKnora/internal/tracing/langfuse"
"github.com/Tencent/WeKnora/internal/types"
+ "github.com/Tencent/WeKnora/internal/types/interfaces"
secutils "github.com/Tencent/WeKnora/internal/utils"
"github.com/google/uuid"
"github.com/hibiken/asynq"
@@ -1321,14 +1323,56 @@ func (s *knowledgeService) triggerManualProcessing(ctx context.Context,
// Resolve embedded data:base64 images and remote http(s) images → storage, replace URLs.
// Runs before chunking so chunks contain stable provider:// URLs.
var resolvedImages []docparser.StoredImage
+ var fileSvc interfaces.FileService
+ var inlineParseErr error
if s.imageResolver != nil {
- fileSvc := s.resolveFileService(ctx, kb)
- afterDataURI, fromDataURI, _ := s.imageResolver.ResolveDataURIImages(ctx, clean, fileSvc, knowledge.TenantID)
- if len(fromDataURI) > 0 {
- logger.Infof(ctx, "Resolved %d data-URI images for manual knowledge %s", len(fromDataURI), knowledge.ID)
- clean = afterDataURI
- resolvedImages = append(resolvedImages, fromDataURI...)
+ fileSvc = s.resolveFileService(ctx, kb)
+ updatedMarkdown, inlineImages, resolveErr := s.imageResolver.ResolveAndStore(ctx,
+ &types.ReadResult{MarkdownContent: clean}, fileSvc, knowledge.TenantID)
+ if errors.Is(resolveErr, docparser.ErrAmbiguousInlineImage) {
+ inlineParseErr = resolveErr
+ inlineImages = nil // ResolveAndStore already rolled back this attempt's uploads.
+ } else if resolveErr != nil {
+ retryCount, _ := asynq.GetRetryCount(ctx)
+ maxRetry, _ := asynq.GetMaxRetry(ctx)
+ if retried, limit, ok := types.TaskRetryMetadataFromContext(ctx); ok {
+ retryCount, maxRetry = retried, limit
+ }
+ if retryCount >= maxRetry {
+ knowledge.ParseStatus = types.ParseStatusFailed
+ knowledge.ErrorMessage = fmt.Sprintf("store manual inline image: %v", resolveErr)
+ knowledge.UpdatedAt = time.Now()
+ if updateErr := s.updateKnowledgeUnlessSourceReplaced(ctx, knowledge); updateErr != nil {
+ logger.Errorf(ctx,
+ "Failed to persist manual inline image failure for %s: %v", knowledge.ID, updateErr)
+ }
+ }
+ return fmt.Errorf("store manual inline image: %w", resolveErr)
+ }
+ if len(inlineImages) > 0 {
+ logger.Infof(ctx, "Resolved %d inline images for manual knowledge %s", len(inlineImages), knowledge.ID)
+ }
+ clean = updatedMarkdown
+ resolvedImages = append(resolvedImages, inlineImages...)
+ }
+ if inlineParseErr != nil || docparser.HasUnresolvedInlineImagePayload(clean) {
+ message := "unresolved inline image base64 payload remains before manual chunking"
+ if inlineParseErr != nil {
+ message = inlineParseErr.Error()
}
+ cleanupUnboundInlineImages(ctx, fileSvc, resolvedImages)
+ knowledge.ParseStatus = types.ParseStatusFailed
+ knowledge.ErrorMessage = message
+ knowledge.UpdatedAt = time.Now()
+ s.beginStage(ctx, knowledge.ID, types.StageChunking, nil)
+ s.failStage(ctx, knowledge.ID, types.StageChunking, werrors.ErrCodeChunkingFailed, message, nil)
+ if err := s.updateKnowledgeUnlessSourceReplaced(ctx, knowledge); err != nil {
+ return fmt.Errorf("%w: persist manual inline image failure: %v", asynq.SkipRetry, err)
+ }
+ return fmt.Errorf("%s: %w", message, asynq.SkipRetry)
+ }
+
+ if s.imageResolver != nil {
updatedContent, storedImages, resolveErr := s.imageResolver.ResolveRemoteImages(ctx, clean, fileSvc, knowledge.TenantID)
if resolveErr != nil {
logger.Warnf(ctx, "Remote image resolution partially failed: %v", resolveErr)
@@ -1365,9 +1409,10 @@ func (s *knowledgeService) triggerManualProcessing(ctx context.Context,
chunkCfg := buildSplitterConfigFromChunking(eff.ChunkingConfig)
var parsed []types.ParsedChunk
+ multimodalImages := imagesForMultimodal(resolvedImages)
opts := ProcessChunksOptions{
- EnableMultimodel: eff.EnableMultimodel && len(resolvedImages) > 0,
- StoredImages: resolvedImages,
+ EnableMultimodel: eff.EnableMultimodel && len(multimodalImages) > 0,
+ StoredImages: multimodalImages,
}
if eff.QuestionGenerationConfig.Enabled {
opts.EnableQuestionGeneration = true
diff --git a/internal/application/service/knowledge_process.go b/internal/application/service/knowledge_process.go
index da664464e..7216d858d 100644
--- a/internal/application/service/knowledge_process.go
+++ b/internal/application/service/knowledge_process.go
@@ -215,6 +215,39 @@ type ProcessChunksOptions struct {
Metadata map[string]string
}
+func imagesForMultimodal(images []docparser.StoredImage) []docparser.StoredImage {
+ selected := make([]docparser.StoredImage, 0, len(images))
+ for _, image := range images {
+ if !image.SkipMultimodal {
+ selected = append(selected, image)
+ }
+ }
+ return selected
+}
+
+func cleanupUnboundInlineImages(
+ ctx context.Context, fileSvc interfaces.FileService, images []docparser.StoredImage,
+) {
+ if fileSvc == nil {
+ return
+ }
+ cleanupCtx, cancel := context.WithTimeout(context.WithoutCancel(ctx), 5*time.Second)
+ defer cancel()
+ deleted := make(map[string]struct{})
+ for _, image := range images {
+ if (!image.Inline && !image.NewlyStored) || image.ServingURL == "" {
+ continue
+ }
+ if _, exists := deleted[image.ServingURL]; exists {
+ continue
+ }
+ deleted[image.ServingURL] = struct{}{}
+ if err := fileSvc.DeleteFile(cleanupCtx, image.ServingURL); err != nil {
+ logger.Warnf(ctx, "Failed to clean up unbound inline image %s: %v", image.ServingURL, err)
+ }
+ }
+}
+
// finalizeIndexedKnowledgeState makes a document retrievable as soon as chunks
// and indexes are persisted (enable_status=enabled), but it deliberately does
// NOT mark the row completed when enrichment is still expected. Whenever the
@@ -4039,22 +4072,50 @@ func (s *knowledgeService) ProcessDocument(ctx context.Context, t *asynq.Task) e
// Step 2: Store images and update markdown references
var storedImages []docparser.StoredImage
+ var imageFileSvc interfaces.FileService
+ var inlineParseErr error
if s.imageResolver != nil && convertResult != nil {
- fileSvc := s.resolveFileService(ctx, kb)
+ imageFileSvc = s.resolveFileService(ctx, kb)
tenantID, _ := ctx.Value(types.TenantIDContextKey).(uint64)
- updatedMarkdown, images, resolveErr := s.imageResolver.ResolveAndStore(ctx, convertResult, fileSvc, tenantID)
- if resolveErr != nil {
- logger.Warnf(ctx, "Image resolution partially failed: %v", resolveErr)
- }
- if updatedMarkdown != "" {
- convertResult.MarkdownContent = updatedMarkdown
+ updatedMarkdown, images, resolveErr := s.imageResolver.ResolveAndStore(
+ ctx, convertResult, imageFileSvc, tenantID)
+ if errors.Is(resolveErr, docparser.ErrAmbiguousInlineImage) {
+ inlineParseErr = resolveErr
+ images = nil // ResolveAndStore already rolled back this attempt's uploads.
+ } else if resolveErr != nil {
+ _, err := s.failKnowledge(ctx, knowledge, isLastRetry, "store inline image: %v", resolveErr)
+ return err
}
+ convertResult.MarkdownContent = updatedMarkdown
storedImages = images
+ }
+ if inlineParseErr != nil ||
+ (convertResult != nil && docparser.HasUnresolvedInlineImagePayload(convertResult.MarkdownContent)) {
+ message := "unresolved inline image base64 payload remains before chunking"
+ if inlineParseErr != nil {
+ message = inlineParseErr.Error()
+ }
+ logger.Errorf(ctx, "Knowledge %s: %s", knowledge.ID, message)
+ cleanupUnboundInlineImages(ctx, imageFileSvc, storedImages)
+ knowledge.ParseStatus = types.ParseStatusFailed
+ knowledge.ErrorMessage = message
+ knowledge.UpdatedAt = time.Now()
+ s.beginStage(ctx, knowledge.ID, types.StageChunking, nil)
+ s.failStage(ctx, knowledge.ID, types.StageChunking, werrors.ErrCodeChunkingFailed, message, nil)
+ if err := s.updateKnowledgeUnlessSourceReplaced(ctx, knowledge); err != nil {
+ return fmt.Errorf("%w: persist inline image processing failure: %v", asynq.SkipRetry, err)
+ }
+ return fmt.Errorf("%s: %w", message, asynq.SkipRetry)
+ }
+
+ if s.imageResolver != nil && convertResult != nil {
+ tenantID, _ := ctx.Value(types.TenantIDContextKey).(uint64)
// Resolve remote http(s) images (e.g. markdown external URLs) → download + upload to storage.
// ResolveAndStore handles inline bytes and base64; ResolveRemoteImages handles http/https URLs.
- updatedContent, remoteImages, remoteErr := s.imageResolver.ResolveRemoteImages(ctx, convertResult.MarkdownContent, fileSvc, tenantID)
+ updatedContent, remoteImages, remoteErr := s.imageResolver.ResolveRemoteImages(
+ ctx, convertResult.MarkdownContent, imageFileSvc, tenantID)
if remoteErr != nil {
logger.Warnf(ctx, "Remote image resolution partially failed: %v", remoteErr)
}
@@ -4081,11 +4142,12 @@ func (s *knowledgeService) ProcessDocument(ctx context.Context, t *asynq.Task) e
// HTML tables were normalized before image resolution above.
chunkCfg := buildSplitterConfigFromChunking(eff.ChunkingConfig)
+ multimodalImages := imagesForMultimodal(storedImages)
processOpts := ProcessChunksOptions{
EnableQuestionGeneration: payload.EnableQuestionGeneration,
QuestionCount: payload.QuestionCount,
EnableMultimodel: payload.EnableMultimodel,
- StoredImages: storedImages,
+ StoredImages: multimodalImages,
}
if convertResult != nil {
diff --git a/internal/application/service/knowledge_process_inline_image_test.go b/internal/application/service/knowledge_process_inline_image_test.go
new file mode 100644
index 000000000..472ff760a
--- /dev/null
+++ b/internal/application/service/knowledge_process_inline_image_test.go
@@ -0,0 +1,972 @@
+package service
+
+import (
+ "bytes"
+ "context"
+ "encoding/base64"
+ "encoding/json"
+ "errors"
+ "fmt"
+ "image"
+ "image/color"
+ "image/png"
+ "io"
+ "strings"
+ "testing"
+
+ "github.com/Tencent/WeKnora/internal/infrastructure/docparser"
+ "github.com/Tencent/WeKnora/internal/models/embedding"
+ "github.com/Tencent/WeKnora/internal/models/vlm"
+ "github.com/Tencent/WeKnora/internal/types"
+ "github.com/Tencent/WeKnora/internal/types/interfaces"
+ "github.com/hibiken/asynq"
+ "github.com/stretchr/testify/require"
+)
+
+type inlineImageFileService struct {
+ interfaces.FileService
+ content string
+ state *inlineImageStorageState
+}
+
+type inlineImageStorageState struct {
+ nextID int
+ failAt int
+ saveCalls int
+ saved []string
+ deleted []string
+ catalog *fakeBindCatalog
+}
+
+func (s inlineImageFileService) GetFile(context.Context, string) (io.ReadCloser, error) {
+ return io.NopCloser(strings.NewReader(s.content)), nil
+}
+
+func (s inlineImageFileService) SaveBytes(context.Context, []byte, uint64, string, bool) (string, error) {
+ if s.state == nil {
+ return "local://test/image.png", nil
+ }
+ s.state.saveCalls++
+ if s.state.failAt > 0 && s.state.saveCalls == s.state.failAt {
+ return "", errors.New("temporary object storage failure")
+ }
+ s.state.nextID++
+ servingURL := fmt.Sprintf("local://test/image-%03d.png", s.state.nextID)
+ s.state.saved = append(s.state.saved, servingURL)
+ if s.state.catalog != nil {
+ if s.state.catalog.resources == nil {
+ s.state.catalog.resources = make(map[string]*types.StoredResource)
+ }
+ s.state.catalog.resources[servingURL] = &types.StoredResource{
+ ID: fmt.Sprintf("resource-%03d", s.state.nextID), TenantID: 1,
+ }
+ }
+ return servingURL, nil
+}
+
+func (s inlineImageFileService) DeleteFile(_ context.Context, filePath string) error {
+ if s.state != nil {
+ s.state.deleted = append(s.state.deleted, filePath)
+ }
+ return nil
+}
+
+type inlineImageChunkRepo struct {
+ interfaces.ChunkRepository
+ deleted bool
+ created bool
+ chunks []*types.Chunk
+}
+
+type inlineImageTenantService struct{ interfaces.TenantService }
+
+type inlineImageModelService struct {
+ interfaces.ModelService
+ calls int
+}
+
+func (s *inlineImageModelService) GetEmbeddingModel(context.Context, string) (embedding.Embedder, error) {
+ s.calls++
+ return nil, errors.New("embedding must not run")
+}
+
+type inlineImageTenantRepo struct {
+ interfaces.TenantRepository
+ tenant *types.Tenant
+}
+
+func (r *inlineImageTenantRepo) GetTenantByID(context.Context, uint64) (*types.Tenant, error) {
+ return r.tenant, nil
+}
+
+func (*inlineImageTenantRepo) AdjustStorageUsed(context.Context, uint64, int64) error { return nil }
+
+type inlineImageSpanTracker struct {
+ noopSpanTracker
+ chunkingStarted bool
+ chunkingFailed bool
+ chunking *Span
+}
+
+func (t *inlineImageSpanTracker) BeginStage(
+ _ context.Context, knowledgeID string, attempt int, stage string, _ types.JSONMap,
+) *Span {
+ if stage != types.StageChunking {
+ return nil
+ }
+ t.chunkingStarted = true
+ t.chunking = &Span{KnowledgeID: knowledgeID, Attempt: attempt, Name: stage, Kind: types.SpanKindStage}
+ return t.chunking
+}
+
+func (t *inlineImageSpanTracker) LookupStage(context.Context, string, int, string) *Span {
+ return t.chunking
+}
+
+func (t *inlineImageSpanTracker) FailSpan(context.Context, *Span, string, string, error) {
+ t.chunkingFailed = true
+}
+
+func (r *inlineImageChunkRepo) DeleteChunksByKnowledgeID(context.Context, uint64, string) error {
+ r.deleted = true
+ return nil
+}
+
+func (r *inlineImageChunkRepo) CreateChunks(_ context.Context, chunks []*types.Chunk) error {
+ r.created = true
+ r.chunks = append([]*types.Chunk(nil), chunks...)
+ return nil
+}
+
+func TestProcessDocumentChunksStoredInlineImagesOverLegacyLimit(t *testing.T) {
+ b64 := base64.StdEncoding.EncodeToString(inlineImageTestPNG(t))
+ image := `<img src="data:image/png;base64,` + b64 + `">`
+
+ for _, count := range []int{31, 81} {
+ t.Run(fmt.Sprintf("%d images", count), func(t *testing.T) {
+ knowledge := &types.Knowledge{
+ ID: "knowledge-1",
+ TenantID: 1,
+ KnowledgeBaseID: "kb-1",
+ FilePath: "input.md",
+ ParseStatus: types.ParseStatusPending,
+ }
+ repo := &embedFailureKnowledgeRepo{knowledge: knowledge}
+ chunkRepo := &inlineImageChunkRepo{}
+ tracker := &inlineImageSpanTracker{}
+ catalog := &fakeBindCatalog{resources: make(map[string]*types.StoredResource)}
+ storage := &inlineImageStorageState{catalog: catalog}
+ fileSvc := inlineImageFileService{content: strings.Repeat(image+"\n", count), state: storage}
+ svc := &knowledgeService{
+ repo: repo,
+ kbService: &reparseFailureKBService{kb: &types.KnowledgeBase{ID: "kb-1", TenantID: 1}},
+ tenantRepo: &inlineImageTenantRepo{tenant: &types.Tenant{ID: 1}},
+ tenantService: &inlineImageTenantService{},
+ fileSvc: fileSvc,
+ imageResolver: docparser.NewImageResolver(),
+ chunkRepo: chunkRepo,
+ graphEngine: parentChildGraphRepo{},
+ spanTracker: tracker,
+ resourceCatalog: catalog,
+ }
+ payload := types.DocumentProcessPayload{
+ TenantID: 1, KnowledgeID: knowledge.ID, KnowledgeBaseID: "kb-1",
+ FilePath: "input.md", FileName: "input.md", FileType: "md", Attempt: 1,
+ }
+ task := asynq.NewTask(types.TypeDocumentProcess, mustMarshalDocumentPayload(t, payload))
+
+ err := svc.ProcessDocument(context.Background(), task)
+
+ require.NoError(t, err)
+ require.NotEqual(t, types.ParseStatusFailed, knowledge.ParseStatus)
+ require.True(t, chunkRepo.created, "stored inline images must be chunked")
+ require.True(t, tracker.chunkingStarted, "the chunking stage must appear in the trace")
+ require.False(t, tracker.chunkingFailed, "the chunking stage must not be marked failed")
+ require.Len(t, storage.saved, count, "each inline image must be stored")
+ require.Len(t, uniqueInlineStrings(storage.saved), count, "each stored image must have a unique URL")
+ require.Len(t, catalog.binds, count, "all stored images, including over-limit ones, must be bound")
+ var chunkText strings.Builder
+ for _, chunk := range chunkRepo.chunks {
+ chunkText.WriteString(chunk.Content)
+ }
+ require.NotContains(t, chunkText.String(), "data:image",
+ "chunk text must not contain inline image payloads")
+ require.NotContains(t, chunkText.String(), "base64,", "chunk text must not contain inline base64")
+ for _, servingURL := range storage.saved {
+ require.Contains(t, chunkText.String(), servingURL, "stored image URL must remain in chunk text")
+ }
+ })
+ }
+}
+
+func TestProcessDocumentChunksCodeExampleAndStoresOnlyRealInlineImage(t *testing.T) {
+ b64 := base64.StdEncoding.EncodeToString(inlineImageTestPNG(t))
+ codeExample := "Use `[![](data:image/png;base64," + b64 + ")](https://example.com)` to illustrate a data URI."
+ realImage := "![](data:image/png;base64," + b64 + ")"
+ knowledge := &types.Knowledge{
+ ID: "knowledge-inline-code-example", TenantID: 1, KnowledgeBaseID: "kb-1",
+ FilePath: "input.md", ParseStatus: types.ParseStatusPending,
+ }
+ chunkRepo := &inlineImageChunkRepo{}
+ tracker := &inlineImageSpanTracker{}
+ catalog := &fakeBindCatalog{resources: make(map[string]*types.StoredResource)}
+ storage := &inlineImageStorageState{catalog: catalog}
+ svc := &knowledgeService{
+ repo: &embedFailureKnowledgeRepo{knowledge: knowledge},
+ kbService: &reparseFailureKBService{kb: &types.KnowledgeBase{ID: "kb-1", TenantID: 1}},
+ tenantRepo: &inlineImageTenantRepo{tenant: &types.Tenant{ID: 1}},
+ tenantService: &inlineImageTenantService{},
+ fileSvc: inlineImageFileService{content: codeExample + "\n\n" + realImage, state: storage},
+ imageResolver: docparser.NewImageResolver(),
+ chunkRepo: chunkRepo,
+ graphEngine: parentChildGraphRepo{},
+ spanTracker: tracker,
+ resourceCatalog: catalog,
+ }
+ payload := types.DocumentProcessPayload{
+ TenantID: 1, KnowledgeID: knowledge.ID, KnowledgeBaseID: "kb-1",
+ FilePath: "input.md", FileName: "input.md", FileType: "md", Attempt: 1,
+ }
+
+ err := svc.ProcessDocument(context.Background(), asynq.NewTask(
+ types.TypeDocumentProcess, mustMarshalDocumentPayload(t, payload)))
+
+ require.NoError(t, err)
+ require.NotEqual(t, types.ParseStatusFailed, knowledge.ParseStatus)
+ require.True(t, chunkRepo.created, "code example must reach chunking")
+ require.True(t, tracker.chunkingStarted)
+ require.False(t, tracker.chunkingFailed)
+ require.Len(t, storage.saved, 1, "only the real inline image should be stored")
+ require.Len(t, catalog.binds, 1)
+ var chunkText strings.Builder
+ for _, chunk := range chunkRepo.chunks {
+ chunkText.WriteString(chunk.Content)
+ }
+ require.Contains(t, chunkText.String(), codeExample, "code example must remain literal text")
+ require.Contains(t, chunkText.String(), storage.saved[0], "real image must be replaced with its stored URL")
+}
+
+func TestProcessDocumentOmitsMalformedImageAndKeepsValidImage(t *testing.T) {
+ validPayload := base64.StdEncoding.EncodeToString(inlineImageTestPNG(t))
+ var largePNG bytes.Buffer
+ require.NoError(t, png.Encode(&largePNG, image.NewGray(image.Rect(0, 0, 6000, 4000))))
+ corrupted := validPayload[:128] + "!" + validPayload[128:] + strings.Repeat("A", 512)
+ svg := `<svg xmlns="http://www.w3.org/2000/svg"><!--` + strings.Repeat("example ", 80) + `--></svg>`
+ svgPayload := base64.RawStdEncoding.EncodeToString([]byte(svg))
+ var wrappedSVG strings.Builder
+ for i := 0; i < len(svgPayload); i += 76 {
+ if i > 0 {
+ wrappedSVG.WriteByte('\n')
+ }
+ wrappedSVG.WriteString(svgPayload[i:min(i+76, len(svgPayload))])
+ }
+ content := "Relevant documentation text.\n" +
+ "data:image/png;base64," + base64.StdEncoding.EncodeToString(largePNG.Bytes()) +
+ "\nPayment terms are net 30 days.\n" +
+ `<img src="data:image/png;base64,` + validPayload[:64] + ">\nPreserved HTML suffix\n" +
+ "![](data:image/png;base64,not-valid-payload)\n" +
+ "data:image/png;base64," + corrupted + "\n这里是商品管理的重要业务说明。\n" +
+ "data:image/png;base64," + validPayload[:76] + "\n这是下一段正常正文。\nDocumentation\nAnotherParagraph\n" +
+ "data:image/svg+xml;base64," + wrappedSVG.String() + "\n" +
+ "![](data:image/png;base64,\n" + validPayload + "\nPayment terms are net 30 days)."
+ knowledge := &types.Knowledge{
+ ID: "knowledge-malformed-inline-image", TenantID: 1, KnowledgeBaseID: "kb-1",
+ FilePath: "input.md", ParseStatus: types.ParseStatusPending,
+ }
+ chunkRepo := &inlineImageChunkRepo{}
+ catalog := &fakeBindCatalog{resources: make(map[string]*types.StoredResource)}
+ storage := &inlineImageStorageState{catalog: catalog}
+ svc := &knowledgeService{
+ repo: &embedFailureKnowledgeRepo{knowledge: knowledge},
+ kbService: &reparseFailureKBService{kb: &types.KnowledgeBase{
+ ID: "kb-1", TenantID: 1,
+ }},
+ tenantRepo: &inlineImageTenantRepo{tenant: &types.Tenant{ID: 1}},
+ tenantService: &inlineImageTenantService{},
+ fileSvc: inlineImageFileService{content: content, state: storage},
+ imageResolver: docparser.NewImageResolver(),
+ chunkRepo: chunkRepo,
+ graphEngine: parentChildGraphRepo{},
+ resourceCatalog: catalog,
+ }
+ payload := types.DocumentProcessPayload{
+ TenantID: 1, KnowledgeID: knowledge.ID, KnowledgeBaseID: "kb-1",
+ FilePath: "input.md", FileName: "input.md", FileType: "md", Attempt: 1,
+ }
+ err := svc.ProcessDocument(context.Background(), asynq.NewTask(
+ types.TypeDocumentProcess, mustMarshalDocumentPayload(t, payload)))
+ require.NoError(t, err)
+ require.NotEqual(t, types.ParseStatusFailed, knowledge.ParseStatus)
+ require.True(t, chunkRepo.created)
+ require.Len(t, storage.saved, 2, "only the valid PNG and SVG images are uploaded")
+ require.Len(t, catalog.binds, 2)
+ var body strings.Builder
+ for _, chunk := range chunkRepo.chunks {
+ body.WriteString(chunk.Content)
+ }
+ require.Contains(t, body.String(), "Relevant documentation text.")
+ require.Contains(t, body.String(), "Preserved HTML suffix")
+ require.Contains(t, body.String(), "这里是商品管理的重要业务说明。")
+ require.Contains(t, body.String(), "这是下一段正常正文。")
+ require.Contains(t, body.String(), "[image omitted]")
+ require.Contains(t, body.String(), storage.saved[0])
+ require.Contains(t, body.String(), storage.saved[1])
+ require.Contains(t, body.String(), "Documentation")
+ require.Contains(t, body.String(), "AnotherParagraph")
+ require.Contains(t, body.String(), "Payment terms are net 30 days).")
+ require.NotContains(t, body.String(), "base64,")
+ require.NotContains(t, body.String(), validPayload[:76])
+ require.NotContains(t, body.String(), base64.StdEncoding.EncodeToString(largePNG.Bytes())[:76])
+}
+
+func TestProcessDocumentAllowsShortDataURIProseExample(t *testing.T) {
+ knowledge := &types.Knowledge{
+ ID: "knowledge-unresolved-inline-image", TenantID: 1, KnowledgeBaseID: "kb-1",
+ FilePath: "input.md", ParseStatus: types.ParseStatusPending,
+ }
+ chunkRepo := &inlineImageChunkRepo{}
+ modelService := &inlineImageModelService{}
+ svc := &knowledgeService{
+ repo: &embedFailureKnowledgeRepo{knowledge: knowledge},
+ kbService: &reparseFailureKBService{kb: &types.KnowledgeBase{
+ ID: "kb-1", TenantID: 1,
+ }},
+ tenantRepo: &inlineImageTenantRepo{tenant: &types.Tenant{ID: 1}},
+ tenantService: &inlineImageTenantService{},
+ fileSvc: inlineImageFileService{
+ content: "Actual image: data:image/png;base64,not-valid-image-payload",
+ },
+ imageResolver: docparser.NewImageResolver(),
+ chunkRepo: chunkRepo,
+ graphEngine: parentChildGraphRepo{},
+ modelService: modelService,
+ }
+ payload := types.DocumentProcessPayload{
+ TenantID: 1, KnowledgeID: knowledge.ID, KnowledgeBaseID: "kb-1",
+ FilePath: "input.md", FileName: "input.md", FileType: "md", Attempt: 1,
+ }
+
+ err := svc.ProcessDocument(context.Background(), asynq.NewTask(
+ types.TypeDocumentProcess, mustMarshalDocumentPayload(t, payload)))
+
+ require.NoError(t, err)
+ require.NotEqual(t, types.ParseStatusFailed, knowledge.ParseStatus)
+ require.True(t, chunkRepo.created)
+ require.Equal(t, 0, modelService.calls)
+}
+
+func TestProcessDocumentEnqueuesOnlyInlineImagesWithinEachSyntaxBudget(t *testing.T) {
+ b64 := base64.StdEncoding.EncodeToString(inlineImageTestPNG(t))
+ markdownImage := `![](data:image/png;base64,` + b64 + `)`
+ htmlImage := `<img src="data:image/png;base64,` + b64 + `">`
+ content := strings.Repeat(markdownImage+"\n", 31) + strings.Repeat(htmlImage+"\n", 31)
+ knowledge := &types.Knowledge{
+ ID: "knowledge-mixed-inline", TenantID: 1, KnowledgeBaseID: "kb-1",
+ FilePath: "input.md", ParseStatus: types.ParseStatusPending,
+ }
+ catalog := &fakeBindCatalog{resources: make(map[string]*types.StoredResource)}
+ storage := &inlineImageStorageState{catalog: catalog}
+ chunkRepo := &inlineImageChunkRepo{}
+ enqueuer := &slotReleaseEnqueuer{}
+ useLiteCounter(t, knowledge.ID)
+ svc := &knowledgeService{
+ repo: &embedFailureKnowledgeRepo{knowledge: knowledge},
+ kbService: &reparseFailureKBService{kb: &types.KnowledgeBase{
+ ID: "kb-1", TenantID: 1, VLMConfig: types.VLMConfig{Enabled: true, ModelID: "vlm"},
+ }},
+ tenantRepo: &inlineImageTenantRepo{tenant: &types.Tenant{ID: 1}},
+ tenantService: &inlineImageTenantService{},
+ fileSvc: inlineImageFileService{content: content, state: storage},
+ imageResolver: docparser.NewImageResolver(),
+ chunkRepo: chunkRepo,
+ graphEngine: parentChildGraphRepo{},
+ resourceCatalog: catalog,
+ task: enqueuer,
+ }
+ payload := types.DocumentProcessPayload{
+ TenantID: 1, KnowledgeID: knowledge.ID, KnowledgeBaseID: "kb-1",
+ FilePath: "input.md", FileName: "input.md", FileType: "md", Attempt: 1,
+ EnableMultimodel: true,
+ }
+
+ err := svc.ProcessDocument(context.Background(), asynq.NewTask(
+ types.TypeDocumentProcess, mustMarshalDocumentPayload(t, payload)))
+
+ require.NoError(t, err)
+ require.Len(t, storage.saved, 62)
+ require.Len(t, uniqueInlineStrings(storage.saved), 62)
+ require.Len(t, catalog.binds, 62)
+ require.Equal(t, 60, enqueuer.imageEnqueued, "Markdown and HTML each keep their own 30-image quota")
+ count, ok := liteCounter(knowledge.ID)
+ require.True(t, ok)
+ require.Equal(t, int64(60), count, "pending count must match the 60 scheduled tasks")
+ require.True(t, chunkRepo.created)
+ var chunkText strings.Builder
+ for _, chunk := range chunkRepo.chunks {
+ chunkText.WriteString(chunk.Content)
+ }
+ require.NotContains(t, chunkText.String(), "data:image")
+ require.NotContains(t, chunkText.String(), "base64,")
+}
+
+type inlineLifecycleFileService struct {
+ inlineImageFileService
+ imageBytes []byte
+}
+
+func (s inlineLifecycleFileService) GetFile(_ context.Context, path string) (io.ReadCloser, error) {
+ if path == "input.md" {
+ return io.NopCloser(strings.NewReader(s.content)), nil
+ }
+ return io.NopCloser(bytes.NewReader(s.imageBytes)), nil
+}
+
+type inlineLifecycleTaskEnqueuer struct {
+ interfaces.TaskEnqueuer
+ imageTasks []*asynq.Task
+ postProcessTasks []*asynq.Task
+}
+
+func (e *inlineLifecycleTaskEnqueuer) Enqueue(task *asynq.Task, _ ...asynq.Option) (*asynq.TaskInfo, error) {
+ switch task.Type() {
+ case types.TypeImageMultimodal:
+ e.imageTasks = append(e.imageTasks, task)
+ case types.TypeKnowledgePostProcess:
+ e.postProcessTasks = append(e.postProcessTasks, task)
+ }
+ return &asynq.TaskInfo{ID: task.Type()}, nil
+}
+
+type inlineLifecycleKnowledgeRepo struct {
+ embedFailureKnowledgeRepo
+}
+
+func (r *inlineLifecycleKnowledgeRepo) GetKnowledgeByIDOnly(
+ context.Context, string,
+) (*types.Knowledge, error) {
+ return r.knowledge, nil
+}
+
+func (r *inlineLifecycleKnowledgeRepo) CompleteProcessingWithoutSubtasks(
+ context.Context, string,
+) (bool, error) {
+ if r.knowledge.ParseStatus != types.ParseStatusProcessing {
+ return false, nil
+ }
+ r.knowledge.ParseStatus = types.ParseStatusCompleted
+ return true, nil
+}
+
+type inlineLifecycleKBService struct {
+ interfaces.KnowledgeBaseService
+ kb *types.KnowledgeBase
+}
+
+func (s *inlineLifecycleKBService) GetKnowledgeBaseByID(context.Context, string) (*types.KnowledgeBase, error) {
+ return s.kb, nil
+}
+
+func (s *inlineLifecycleKBService) GetKnowledgeBaseByIDOnly(context.Context, string) (*types.KnowledgeBase, error) {
+ return s.kb, nil
+}
+
+const (
+ inlineLifecycleOCRText = "inline lifecycle OCR text extracted from the document image"
+ inlineLifecycleCaptionText = "inline lifecycle caption describing the document image"
+)
+
+type inlineLifecycleVLM struct{ captionCalls, ocrCalls int }
+
+func (m *inlineLifecycleVLM) Predict(_ context.Context, _ [][]byte, prompt string) (string, error) {
+ if strings.Contains(prompt, "OCR assistant") {
+ m.ocrCalls++
+ return inlineLifecycleOCRText, nil
+ }
+ m.captionCalls++
+ return inlineLifecycleCaptionText, nil
+}
+
+func (m *inlineLifecycleVLM) PredictWithOptions(
+ ctx context.Context, imgBytes [][]byte, prompt string, _ *vlm.PredictOptions,
+) (string, error) {
+ return m.Predict(ctx, imgBytes, prompt)
+}
+
+func (*inlineLifecycleVLM) GetModelName() string { return "inline-lifecycle-vlm" }
+func (*inlineLifecycleVLM) GetModelID() string { return "inline-lifecycle-vlm" }
+
+type inlineLifecycleChunkRepo struct {
+ *inlineImageChunkRepo
+}
+
+// CreateChunks appends across calls: 30 image tasks each persist their child
+// chunks through this repo, and the test inspects the full set afterwards.
+func (r *inlineLifecycleChunkRepo) CreateChunks(_ context.Context, chunks []*types.Chunk) error {
+ r.created = true
+ r.chunks = append(r.chunks, chunks...)
+ return nil
+}
+
+func (*inlineLifecycleChunkRepo) UpdateChunk(context.Context, *types.Chunk) error { return nil }
+
+type inlineLifecycleChunkService struct {
+ interfaces.ChunkService
+ repo *inlineLifecycleChunkRepo
+}
+
+func (s *inlineLifecycleChunkService) GetRepository() interfaces.ChunkRepository { return s.repo }
+
+func (s *inlineLifecycleChunkService) GetChunkByIDOnly(_ context.Context, id string) (*types.Chunk, error) {
+ for _, chunk := range s.repo.chunks {
+ if chunk.ID == id {
+ return chunk, nil
+ }
+ }
+ return nil, fmt.Errorf("chunk %s not found", id)
+}
+
+type inlineLifecycleModelService struct {
+ interfaces.ModelService
+ model vlm.VLM
+}
+
+func (s inlineLifecycleModelService) GetVLMModel(context.Context, string) (vlm.VLM, error) {
+ return s.model, nil
+}
+
+func TestProcessDocumentInlineImageTasksCompleteKnowledge(t *testing.T) {
+ const knowledgeID = "knowledge-inline-image-lifecycle"
+ b64 := base64.StdEncoding.EncodeToString(inlineImageTestPNG(t))
+ image := `<img src="data:image/png;base64,` + b64 + `">`
+ content := strings.Repeat(image+"\n", 81)
+ knowledge := &types.Knowledge{
+ ID: knowledgeID, TenantID: 1, KnowledgeBaseID: "kb-inline-lifecycle",
+ FilePath: "input.md", ParseStatus: types.ParseStatusPending,
+ }
+ require.NoError(t, knowledge.SetProcessOverrides(&types.KnowledgeProcessOverrides{
+ SummaryEnabled: processConfigBoolPtr(false),
+ }))
+ kb := &types.KnowledgeBase{
+ ID: knowledge.KnowledgeBaseID, TenantID: knowledge.TenantID,
+ Type: types.KnowledgeBaseTypeDocument,
+ VLMConfig: types.VLMConfig{Enabled: true, ModelID: "inline-lifecycle-vlm"},
+ }
+ repo := &inlineLifecycleKnowledgeRepo{embedFailureKnowledgeRepo: embedFailureKnowledgeRepo{knowledge: knowledge}}
+ kbService := &inlineLifecycleKBService{kb: kb}
+ catalog := &fakeBindCatalog{resources: make(map[string]*types.StoredResource)}
+ storage := &inlineImageStorageState{catalog: catalog}
+ fileSvc := inlineLifecycleFileService{
+ inlineImageFileService: inlineImageFileService{content: content, state: storage},
+ imageBytes: inlineImageTestPNG(t),
+ }
+ chunkRepo := &inlineImageChunkRepo{}
+ queue := &inlineLifecycleTaskEnqueuer{}
+ useLiteCounter(t, knowledgeID)
+ processService := &knowledgeService{
+ repo: repo, kbService: kbService,
+ tenantRepo: &inlineImageTenantRepo{tenant: &types.Tenant{ID: 1}},
+ tenantService: &inlineImageTenantService{},
+ fileSvc: fileSvc, imageResolver: docparser.NewImageResolver(),
+ chunkRepo: chunkRepo, graphEngine: parentChildGraphRepo{},
+ resourceCatalog: catalog, task: queue,
+ }
+ payload := types.DocumentProcessPayload{
+ TenantID: 1, KnowledgeID: knowledgeID, KnowledgeBaseID: kb.ID,
+ FilePath: "input.md", FileName: "input.md", FileType: "md", Attempt: 1,
+ EnableMultimodel: true,
+ }
+
+ require.NoError(t, processService.ProcessDocument(context.Background(), asynq.NewTask(
+ types.TypeDocumentProcess, mustMarshalDocumentPayload(t, payload))))
+ require.Len(t, storage.saved, 81)
+ require.Len(t, catalog.binds, 81)
+ require.Len(
+ t, queue.imageTasks, 30,
+ "only the first 30 HTML inline images in document order should run through multimodal processing",
+ )
+ require.Equal(t, types.ParseStatusProcessing, knowledge.ParseStatus,
+ "knowledge must stay processing while image tasks are queued")
+ pending, ok := liteCounter(knowledgeID)
+ require.True(t, ok)
+ require.Equal(t, int64(30), pending)
+
+ model := &inlineLifecycleVLM{}
+ imageService := &ImageMultimodalService{
+ chunkService: &inlineLifecycleChunkService{
+ repo: &inlineLifecycleChunkRepo{inlineImageChunkRepo: chunkRepo},
+ },
+ knowledgeRepo: repo,
+ kbService: kbService,
+ modelService: inlineLifecycleModelService{model: model},
+ tenantRepo: &inlineImageTenantRepo{tenant: &types.Tenant{ID: 1}},
+ fileSvc: fileSvc,
+ taskEnqueuer: queue,
+ }
+ for _, task := range queue.imageTasks {
+ require.NoError(t, imageService.Handle(context.Background(), task))
+ }
+ require.Equal(t, 30, model.captionCalls, "each image task should complete one caption call")
+ require.Equal(t, 30, model.ocrCalls, "each image task should complete one OCR call")
+
+ ownerByURL := make(map[string]string, len(queue.imageTasks))
+ ownedImages := 0
+ for _, task := range queue.imageTasks {
+ var payload types.ImageMultimodalPayload
+ require.NoError(t, json.Unmarshal(task.Payload(), &payload))
+ ownerByURL[payload.ImageURL] = payload.ChunkID
+ if payload.ChunkID != "" {
+ ownedImages++
+ }
+ }
+ require.Positive(t, ownedImages, "scheduled images should mostly resolve to an owning text chunk")
+ chunksByID := make(map[string]*types.Chunk, len(chunkRepo.chunks))
+ ocrChunks, captionChunks := 0, 0
+ for _, chunk := range chunkRepo.chunks {
+ chunksByID[chunk.ID] = chunk
+ switch chunk.ChunkType {
+ case types.ChunkTypeImageOCR:
+ ocrChunks++
+ require.Equal(t, inlineLifecycleOCRText, chunk.Content)
+ case types.ChunkTypeImageCaption:
+ captionChunks++
+ require.Equal(t, inlineLifecycleCaptionText, chunk.Content)
+ }
+ }
+ require.Equal(t, 30, ocrChunks, "each scheduled image should produce an OCR chunk from the VLM output")
+ require.Equal(t, 30, captionChunks, "each scheduled image should produce a caption chunk from the VLM output")
+ for _, chunk := range chunkRepo.chunks {
+ if chunk.ChunkType != types.ChunkTypeImageOCR && chunk.ChunkType != types.ChunkTypeImageCaption {
+ continue
+ }
+ var infos []types.ImageInfo
+ require.NoError(t, json.Unmarshal([]byte(chunk.ImageInfo), &infos))
+ require.Len(t, infos, 1)
+ owner, ok := ownerByURL[infos[0].URL]
+ require.True(t, ok, "multimodal chunk %s must reference one of the scheduled images", chunk.ID)
+ require.Equal(t, owner, chunk.ParentChunkID)
+ if owner == "" {
+ // imageChunkOwner leaves ownership unset when chunk overlap puts the
+ // same URL in more than one chunk — the child stays unattached.
+ continue
+ }
+ parent, ok := chunksByID[chunk.ParentChunkID]
+ require.True(t, ok, "parent chunk %s must exist", chunk.ParentChunkID)
+ require.Contains(t, parent.Content, infos[0].URL,
+ "the parent text chunk must be the one carrying the image")
+ }
+ _, ok = liteCounter(knowledgeID)
+ require.False(t, ok, "the pending counter should be removed when all 30 image tasks finish")
+ require.Len(t, queue.postProcessTasks, 1,
+ "the last completed image task should enqueue exactly one post-process task")
+ require.Equal(t, types.ParseStatusProcessing, knowledge.ParseStatus,
+ "image completion should hand off to post-process before marking the document complete")
+
+ postProcessRepo := &wikiEnqueueFailureChunkRepo{chunks: chunkRepo.chunks}
+ postProcessService := &KnowledgePostProcessService{
+ knowledgeRepo: repo,
+ kbService: kbService,
+ chunkRepo: postProcessRepo,
+ taskEnqueuer: queue,
+ }
+ require.NoError(t, postProcessService.Handle(context.Background(), queue.postProcessTasks[0]))
+ require.Equal(t, types.ParseStatusCompleted, knowledge.ParseStatus,
+ "post-process should move the document to Completed after all image work finishes")
+}
+
+func TestTriggerManualProcessingStoresAndLimitsInlineImages(t *testing.T) {
+ b64 := base64.StdEncoding.EncodeToString(inlineImageTestPNG(t))
+ image := `<img src="data:image/png;base64,` + b64 + `">`
+ codeExample := "`[![](data:image/png;base64," + b64 + ")](https://example.com)`"
+ content := `<img src="data:image/png;base64,` + b64[:64] + ">\nPreserved manual suffix\n" +
+ "base64," + b64[:76] + "\n这里是手动录入的业务说明。\n" +
+ codeExample + "\n\n" + strings.Repeat(image+"\n", 80) +
+ "data:image/png;base64,\n" + b64
+ knowledge := &types.Knowledge{
+ ID: "knowledge-manual-inline", TenantID: 1, KnowledgeBaseID: "kb-1",
+ ParseStatus: types.ParseStatusProcessing,
+ }
+ catalog := &fakeBindCatalog{resources: make(map[string]*types.StoredResource)}
+ storage := &inlineImageStorageState{catalog: catalog}
+ chunkRepo := &inlineImageChunkRepo{}
+ enqueuer := &slotReleaseEnqueuer{}
+ useLiteCounter(t, knowledge.ID)
+ ctx := context.WithValue(context.Background(), types.TenantInfoContextKey, &types.Tenant{ID: 1})
+ svc := &knowledgeService{
+ repo: &embedFailureKnowledgeRepo{knowledge: knowledge},
+ fileSvc: inlineImageFileService{state: storage},
+ imageResolver: docparser.NewImageResolver(),
+ resourceCatalog: catalog,
+ chunkRepo: chunkRepo,
+ modelService: embedFailureModelService{err: errors.New("embedding should be disabled")},
+ graphEngine: parentChildGraphRepo{},
+ tenantRepo: parentChildTenantRepo{},
+ task: enqueuer,
+ }
+ kb := &types.KnowledgeBase{
+ ID: "kb-1", TenantID: 1, VLMConfig: types.VLMConfig{Enabled: true, ModelID: "vlm"},
+ }
+
+ err := svc.triggerManualProcessing(ctx, kb, knowledge, content, true)
+
+ require.NoError(t, err)
+ require.Len(t, storage.saved, 81)
+ require.Len(t, uniqueInlineStrings(storage.saved), 81)
+ require.Len(t, catalog.binds, 81, "all images must be bound, including the 50 beyond the AI quota")
+ require.Equal(t, 31, enqueuer.imageEnqueued, "30 HTML images and one bare image have separate quotas")
+ count, ok := liteCounter(knowledge.ID)
+ require.True(t, ok)
+ require.Equal(t, int64(31), count, "pending count must match the scheduled tasks")
+ require.True(t, chunkRepo.created)
+ var chunkText strings.Builder
+ for _, chunk := range chunkRepo.chunks {
+ chunkText.WriteString(chunk.Content)
+ }
+ require.Contains(t, chunkText.String(), codeExample)
+ require.Contains(t, chunkText.String(), "Preserved manual suffix")
+ require.Contains(t, chunkText.String(), "这里是手动录入的业务说明。")
+ resolvedText := strings.ReplaceAll(chunkText.String(), codeExample, "")
+ require.NotContains(t, resolvedText, "data:image")
+ require.NotContains(t, resolvedText, "base64,")
+ require.NotContains(t, resolvedText, b64[:76])
+ for _, servingURL := range storage.saved {
+ require.Contains(t, chunkText.String(), servingURL)
+ }
+}
+
+func TestTriggerManualProcessingRetriesAndRollsBackStorageFailure(t *testing.T) {
+ b64 := base64.StdEncoding.EncodeToString(inlineImageTestPNG(t))
+ image := `<img src="data:image/png;base64,` + b64 + `">`
+ knowledge := &types.Knowledge{
+ ID: "knowledge-manual-storage-failure", TenantID: 1, KnowledgeBaseID: "kb-1",
+ ParseStatus: types.ParseStatusProcessing,
+ }
+ storage := &inlineImageStorageState{failAt: 2}
+ chunkRepo := &inlineImageChunkRepo{}
+ repo := &embedFailureKnowledgeRepo{knowledge: knowledge}
+ ctx := context.WithValue(context.Background(), types.TenantInfoContextKey, &types.Tenant{ID: 1})
+ ctx = types.WithTaskRetryMetadata(ctx, 0, 3)
+ svc := &knowledgeService{
+ repo: repo,
+ fileSvc: inlineImageFileService{state: storage},
+ imageResolver: docparser.NewImageResolver(),
+ chunkRepo: chunkRepo,
+ }
+ kb := &types.KnowledgeBase{ID: "kb-1", TenantID: 1}
+
+ err := svc.triggerManualProcessing(ctx, kb, knowledge, strings.Repeat(image+"\n", 2), true)
+
+ require.ErrorContains(t, err, "temporary object storage failure")
+ require.False(t, errors.Is(err, asynq.SkipRetry), "temporary storage failures must be retried")
+ require.Equal(t, types.ParseStatusProcessing, knowledge.ParseStatus,
+ "the row must remain processing until retries are exhausted")
+ require.Empty(t, repo.updates, "do not persist a terminal failure on a retryable attempt")
+ require.False(t, chunkRepo.created, "manual content must not reach chunking after storage failure")
+ require.Len(t, storage.saved, 1)
+ require.Equal(t, storage.saved, storage.deleted,
+ "the successful partial save must be removed before the retry")
+}
+
+func TestImagesForMultimodalKeepsOtherImageSourcesUnchanged(t *testing.T) {
+ images := make([]docparser.StoredImage, 0, 161)
+ for i := 0; i < 81; i++ {
+ images = append(images, docparser.StoredImage{
+ ServingURL: fmt.Sprintf("local://inline/%d", i),
+ Inline: true,
+ SkipMultimodal: i >= 30,
+ })
+ }
+ for i := 0; i < 50; i++ {
+ images = append(images, docparser.StoredImage{ServingURL: fmt.Sprintf("local://pdf/%d", i)})
+ }
+ for i := 0; i < 30; i++ {
+ images = append(images, docparser.StoredImage{ServingURL: fmt.Sprintf("local://remote/%d", i)})
+ }
+
+ selected := imagesForMultimodal(images)
+ require.Len(t, selected, 110)
+ for _, image := range selected {
+ require.False(t, image.SkipMultimodal)
+ }
+}
+
+func TestAmbiguousInlineImageStopsIngestionAndRollsBack(t *testing.T) {
+ b64 := base64.StdEncoding.EncodeToString(inlineImageTestPNG(t))
+ for _, manual := range []bool{false, true} {
+ for _, prefix := range []string{"data:image/png;base64,", "base64,"} {
+ t.Run(fmt.Sprintf("manual=%t/%s", manual, prefix), func(t *testing.T) {
+ content := "![](data:image/png;base64," + b64 + ")\n\n" +
+ prefix + b64[:76] + "\n" + b64[76:152] + "\nPayment terms are net 30 days."
+ knowledge := &types.Knowledge{
+ ID: "ambiguous-inline", TenantID: 1, KnowledgeBaseID: "kb-1",
+ FilePath: "input.md", ParseStatus: types.ParseStatusProcessing,
+ }
+ kb := &types.KnowledgeBase{ID: "kb-1", TenantID: 1}
+ catalog := &fakeBindCatalog{resources: make(map[string]*types.StoredResource)}
+ storage := &inlineImageStorageState{catalog: catalog}
+ chunks := &inlineImageChunkRepo{}
+ model := &inlineImageModelService{}
+ tracker := &inlineImageSpanTracker{}
+ svc := &knowledgeService{
+ repo: &embedFailureKnowledgeRepo{knowledge: knowledge},
+ kbService: &reparseFailureKBService{kb: kb},
+ fileSvc: inlineImageFileService{content: content, state: storage},
+ imageResolver: docparser.NewImageResolver(), resourceCatalog: catalog,
+ chunkRepo: chunks, modelService: model, spanTracker: tracker,
+ tenantRepo: &inlineImageTenantRepo{tenant: &types.Tenant{ID: 1}},
+ tenantService: &inlineImageTenantService{}, graphEngine: parentChildGraphRepo{},
+ }
+ ctx := context.WithValue(context.Background(), types.TenantInfoContextKey, &types.Tenant{ID: 1})
+ ctx = types.WithTaskRetryMetadata(ctx, 0, 3)
+ ctx = withAttempt(ctx, 1)
+ var err error
+ if manual {
+ err = svc.triggerManualProcessing(ctx, kb, knowledge, content, true)
+ } else {
+ payload := types.DocumentProcessPayload{
+ TenantID: 1, KnowledgeID: knowledge.ID, KnowledgeBaseID: kb.ID,
+ FilePath: "input.md", FileName: "input.md", FileType: "md", Attempt: 1,
+ }
+ err = svc.ProcessDocument(ctx, asynq.NewTask(
+ types.TypeDocumentProcess, mustMarshalDocumentPayload(t, payload)))
+ }
+ require.ErrorIs(t, err, asynq.SkipRetry, "malformed content must fail on the first attempt")
+ require.Contains(t, knowledge.ErrorMessage, "malformed multiline inline image")
+ require.Equal(t, types.ParseStatusFailed, knowledge.ParseStatus)
+ require.True(t, tracker.chunkingFailed)
+ require.False(t, chunks.created)
+ require.Zero(t, model.calls)
+ require.Empty(t, catalog.binds)
+ require.Len(t, storage.saved, 1)
+ require.Equal(t, storage.saved, storage.deleted, "each partial upload must be deleted once")
+ })
+ }
+ }
+}
+
+func TestProcessDocumentRetriesInlineImageStorageFailure(t *testing.T) {
+ b64 := base64.StdEncoding.EncodeToString(inlineImageTestPNG(t))
+ image := `<img src="data:image/png;base64,` + b64 + `">`
+ storage := &inlineImageStorageState{failAt: 2}
+ knowledge := &types.Knowledge{
+ ID: "knowledge-storage-failure", TenantID: 1, KnowledgeBaseID: "kb-1",
+ FilePath: "input.md", ParseStatus: types.ParseStatusPending,
+ }
+ chunkRepo := &inlineImageChunkRepo{}
+ modelService := &inlineImageModelService{}
+ svc := &knowledgeService{
+ repo: &embedFailureKnowledgeRepo{knowledge: knowledge},
+ kbService: &reparseFailureKBService{kb: &types.KnowledgeBase{
+ ID: "kb-1", TenantID: 1, EmbeddingModelID: "embedding-1",
+ IndexingStrategy: types.IndexingStrategy{VectorEnabled: true},
+ }},
+ tenantRepo: &inlineImageTenantRepo{tenant: &types.Tenant{ID: 1}},
+ tenantService: &inlineImageTenantService{},
+ fileSvc: inlineImageFileService{content: strings.Repeat(image+"\n", 2), state: storage},
+ imageResolver: docparser.NewImageResolver(),
+ chunkRepo: chunkRepo,
+ graphEngine: parentChildGraphRepo{},
+ modelService: modelService,
+ }
+ payload := types.DocumentProcessPayload{
+ TenantID: 1, KnowledgeID: knowledge.ID, KnowledgeBaseID: "kb-1",
+ FilePath: "input.md", FileName: "input.md", FileType: "md", Attempt: 1,
+ }
+
+ ctx := types.WithTaskRetryMetadata(context.Background(), 0, 3)
+ err := svc.ProcessDocument(ctx, asynq.NewTask(
+ types.TypeDocumentProcess, mustMarshalDocumentPayload(t, payload)))
+
+ require.ErrorContains(t, err, "temporary object storage failure")
+ require.False(t, errors.Is(err, asynq.SkipRetry))
+ require.False(t, chunkRepo.created)
+ require.Equal(t, 0, modelService.calls, "embedding must not be reached after storage failure")
+ require.NotEqual(t, types.ParseStatusFailed, knowledge.ParseStatus,
+ "a retryable storage failure must not mark the document terminally failed")
+ require.Len(t, storage.saved, 1)
+ require.Equal(t, storage.saved, storage.deleted, "partial inline saves must be rolled back before retry")
+}
+
+func uniqueInlineStrings(values []string) []string {
+ seen := make(map[string]struct{}, len(values))
+ for _, value := range values {
+ seen[value] = struct{}{}
+ }
+ return keysOfStringSet(seen)
+}
+
+func keysOfStringSet(values map[string]struct{}) []string {
+ keys := make([]string, 0, len(values))
+ for value := range values {
+ keys = append(keys, value)
+ }
+ return keys
+}
+
+func inlineImageTestPNG(t *testing.T) []byte {
+ t.Helper()
+ img := image.NewRGBA(image.Rect(0, 0, 200, 150))
+ for y := 0; y < 150; y++ {
+ for x := 0; x < 200; x++ {
+ img.Set(x, y, color.RGBA{R: 128, G: 128, B: 128, A: 255})
+ }
+ }
+ var out bytes.Buffer
+ require.NoError(t, png.Encode(&out, img))
+ return out.Bytes()
+}
+
+func mustMarshalDocumentPayload(t *testing.T, payload types.DocumentProcessPayload) []byte {
+ t.Helper()
+ data, err := json.Marshal(payload)
+ require.NoError(t, err)
+ return data
+}
+
+func TestProcessDocumentIconOnlyContentCompletesEmptyBody(t *testing.T) {
+ var icon bytes.Buffer
+ require.NoError(t, png.Encode(&icon, image.NewRGBA(image.Rect(0, 0, 32, 32))))
+ content := "![](data:image/png;base64," + base64.StdEncoding.EncodeToString(icon.Bytes()) + ")"
+ for _, parentChild := range []bool{false, true} {
+ t.Run(fmt.Sprint(parentChild), func(t *testing.T) {
+ knowledge := &types.Knowledge{
+ ID: "knowledge-icon-only", TenantID: 1, KnowledgeBaseID: "kb-1",
+ FilePath: "input.md", ParseStatus: types.ParseStatusPending,
+ }
+ require.NoError(t, knowledge.SetProcessOverrides(&types.KnowledgeProcessOverrides{
+ SummaryEnabled: processConfigBoolPtr(false),
+ }))
+ kb := &types.KnowledgeBase{
+ ID: "kb-1", TenantID: 1, ChunkingConfig: types.ChunkingConfig{EnableParentChild: parentChild},
+ }
+ chunkRepo := &inlineImageChunkRepo{}
+ tracker := &inlineImageSpanTracker{}
+ catalog := &fakeBindCatalog{resources: make(map[string]*types.StoredResource)}
+ storage := &inlineImageStorageState{catalog: catalog}
+ queue := &inlineLifecycleTaskEnqueuer{}
+ svc := &knowledgeService{
+ repo: &embedFailureKnowledgeRepo{knowledge: knowledge}, kbService: &reparseFailureKBService{kb: kb},
+ tenantRepo: &inlineImageTenantRepo{tenant: &types.Tenant{ID: 1}},
+ tenantService: &inlineImageTenantService{},
+ fileSvc: inlineImageFileService{content: content, state: storage},
+ imageResolver: docparser.NewImageResolver(),
+ chunkRepo: chunkRepo, graphEngine: parentChildGraphRepo{}, spanTracker: tracker,
+ resourceCatalog: catalog, task: queue,
+ }
+ payload := types.DocumentProcessPayload{
+ TenantID: 1, KnowledgeID: knowledge.ID, KnowledgeBaseID: kb.ID,
+ FilePath: "input.md", FileName: "input.md", FileType: "md", Attempt: 1, EnableMultimodel: true,
+ }
+ err := svc.ProcessDocument(context.Background(), asynq.NewTask(
+ types.TypeDocumentProcess, mustMarshalDocumentPayload(t, payload)))
+ require.NoError(t, err)
+ require.Equal(t, types.ParseStatusCompleted, knowledge.ParseStatus)
+ require.Empty(t, knowledge.ErrorMessage)
+ require.True(t, tracker.chunkingStarted)
+ require.False(t, tracker.chunkingFailed)
+ require.Empty(t, chunkRepo.chunks, "empty resolved content must not enter embedding")
+ require.Empty(t, storage.saved)
+ require.Empty(t, catalog.binds)
+ require.Empty(t, queue.imageTasks)
+ })
+ }
+}
diff --git a/internal/infrastructure/docparser/image_resolver.go b/internal/infrastructure/docparser/image_resolver.go
index b7c2e67f7..5eaf9c050 100644
--- a/internal/infrastructure/docparser/image_resolver.go
+++ b/internal/infrastructure/docparser/image_resolver.go
@@ -4,11 +4,13 @@ import (
"bytes"
"context"
"encoding/base64"
+ "encoding/binary"
+ "encoding/xml"
"errors"
"fmt"
"html"
"image"
- _ "image/gif"
+ "image/gif"
_ "image/jpeg"
_ "image/png"
"io"
@@ -23,6 +25,11 @@ import (
"sort"
"strings"
"time"
+ "unicode"
+ "unicode/utf8"
+
+ _ "golang.org/x/image/bmp" // Register BMP decoding for image.Decode and DecodeConfig.
+ _ "golang.org/x/image/webp" // Register WebP decoding for image.Decode and DecodeConfig.
"github.com/Tencent/WeKnora/internal/searchutil"
secutils "github.com/Tencent/WeKnora/internal/utils"
@@ -39,6 +46,9 @@ const (
// minImageBytes is the minimum file size in bytes; very small images are
// almost certainly icons or decorative elements.
minImageBytes = 512 // 512 bytes
+ // inlineImageRollbackTimeout bounds cleanup even if the request context was
+ // cancelled while one of the inline image saves was failing.
+ inlineImageRollbackTimeout = 5 * time.Second
)
// isIconImage returns true if the image data looks like a small icon or
@@ -61,6 +71,16 @@ type StoredImage struct {
OriginalRef string // reference in the original markdown
ServingURL string // provider:// URL (e.g. local://images/xxx.png, minio://bucket/key)
MimeType string
+ // Inline marks Base64 images stored from inline document content, so only
+ // resources created by this resolver are eligible for partial-save cleanup.
+ Inline bool
+ // NewlyStored marks a resource created by this resolver invocation, including
+ // document-parser ImageRefs, so guard failures can clean up unbound uploads.
+ NewlyStored bool
+ // SkipMultimodal keeps a saved inline image out of OCR/caption fan-out once
+ // its syntax-specific legacy budget is exhausted. The image still remains in
+ // the document and resource bindings.
+ SkipMultimodal bool
// SourceLocators place the image in the original file (e.g. the scanned
// page it was rendered from). Filled by ingestion after resolution.
SourceLocators types.SourceLocators
@@ -87,18 +107,51 @@ func (r *ImageResolver) ResolveAndStore(
fileSvc interfaces.FileService,
tenantID uint64,
) (updatedMarkdown string, images []StoredImage, err error) {
+ var inlineImages []StoredImage
+ defer func() {
+ if err == nil {
+ return
+ }
+ updatedMarkdown = result.MarkdownContent
+ if fileSvc == nil {
+ return
+ }
+ rollbackCtx, cancel := context.WithTimeout(context.WithoutCancel(ctx), inlineImageRollbackTimeout)
+ defer cancel()
+ for _, image := range inlineImages {
+ if deleteErr := fileSvc.DeleteFile(rollbackCtx, image.ServingURL); deleteErr != nil {
+ log.Printf("WARN: failed to rollback inline image %s: %v", image.ServingURL, deleteErr)
+ }
+ }
+ }()
+
+ ctx = context.WithValue(ctx, inlineQuotaKey{}, &inlineQuota{})
markdown := UnwrapLinkedImages(result.MarkdownContent)
- md2, imgDataURIs, _ := r.ResolveDataURIImages(ctx, markdown, fileSvc, tenantID)
- markdown = md2
+ // When the document-wide storage cap is reached, this resolver order gives
+ // Markdown, HTML, then bare Base64 references deterministic priority.
+ md2, imgDataURIs, err := r.ResolveDataURIImages(ctx, markdown, fileSvc, tenantID)
+ inlineImages = append(inlineImages, imgDataURIs...)
images = append(images, imgDataURIs...)
+ if err != nil {
+ return markdown, images, err
+ }
+ markdown = md2
- md3, imgHTML, _ := r.ResolveHTMLDataURIImages(ctx, markdown, fileSvc, tenantID)
- markdown = md3
+ md3, imgHTML, err := r.ResolveHTMLDataURIImages(ctx, markdown, fileSvc, tenantID)
+ inlineImages = append(inlineImages, imgHTML...)
images = append(images, imgHTML...)
+ if err != nil {
+ return markdown, images, err
+ }
+ markdown = md3
- md4, imgBare, _ := r.ResolveBareBase64Content(ctx, markdown, fileSvc, tenantID)
- markdown = md4
+ md4, imgBare, err := r.ResolveBareBase64Content(ctx, markdown, fileSvc, tenantID)
+ inlineImages = append(inlineImages, imgBare...)
images = append(images, imgBare...)
+ if err != nil {
+ return markdown, images, err
+ }
+ markdown = md4
if len(result.ImageRefs) == 0 {
return markdown, sortImagesByPosition(markdown, images), nil
@@ -230,6 +283,7 @@ func (r *ImageResolver) saveReferencedImage(
OriginalRef: refPath,
ServingURL: servingURL,
MimeType: ref.MimeType,
+ NewlyStored: true,
}
savedRefs[refPath] = stored
if ref.Filename != "" {
@@ -348,13 +402,39 @@ func sniffImageMime(data []byte) string {
return ""
}
+func sniffInlineImageMime(data []byte) string {
+ if mimeType := sniffImageMime(data); mimeType != "" {
+ return mimeType
+ }
+ // Read through declarations and comments without imposing a prefix length.
+ decoder := xml.NewDecoder(bytes.NewReader(data))
+ for {
+ token, err := decoder.Token()
+ if err != nil {
+ break
+ }
+ if text, ok := token.(xml.CharData); ok && len(bytes.TrimSpace(text)) != 0 {
+ break
+ }
+ if root, ok := token.(xml.StartElement); ok {
+ if root.Name.Local == "svg" {
+ return "image/svg+xml"
+ }
+ break
+ }
+ }
+
+ return ""
+}
+
// ---------------------------------------------------------------------------
// HTML <img> tag data URI resolution
// ---------------------------------------------------------------------------
// imgHTMLDataURI matches HTML <img> tags with inline data:image/*;base64,... in the src attribute.
+// A missing quote must not extend the payload into subsequent tags or prose.
var imgHTMLDataURI = regexp.MustCompile(
- `(?i)<img\s[^>]*?src\s*=\s*["'](data:image/[^;]+;base64,[^"']+)["'][^>]*?/?\s*>`,
+ `(?i)<img\s[^>]*?src\s*=\s*["'](data:image/[^;<>]+;base64,[^"'<>]+)["'][^>]*?/?\s*>`,
)
// imgHTMLSrc matches an HTML <img> tag carrying a quoted src attribute. It does
@@ -367,6 +447,69 @@ var imgHTMLDataURI = regexp.MustCompile(
// the submatch layout and the known limits.
var imgHTMLSrc = searchutil.HTMLImageSrcRegex
+// Inline resource caps are independent from the legacy per-syntax 30-image AI budget.
+// Excess images are omitted instead of leaving Base64 in searchable text.
+const (
+ maxInlineImagesPerDocument = 1000
+ maxInlineBytesPerDocument = 100 * 1024 * 1024
+ inlineImageOmitted = "[image omitted]"
+)
+
+type inlineQuotaKey struct{}
+
+type inlineQuota struct {
+ count int
+ bytes int
+}
+
+// Check decoded-byte limits before allocating a potentially huge image.
+func oversizedInlinePayload(payload string) bool {
+ return len(payload) > ((maxRemoteImageSize+2)/3)*4
+}
+
+func quotaForInlineImages(ctx context.Context) *inlineQuota {
+ if q, ok := ctx.Value(inlineQuotaKey{}).(*inlineQuota); ok {
+ return q
+ }
+ return &inlineQuota{}
+}
+
+func (q *inlineQuota) permits(size int) bool {
+ if q.count >= maxInlineImagesPerDocument || size > maxInlineBytesPerDocument-q.bytes {
+ return false
+ }
+ q.count++
+ q.bytes += size
+ return true
+}
+
+type inlineRewrite struct {
+ start int
+ end int
+ value string
+}
+
+// The regex match offsets refer to the original Markdown. Build the output
+// in one pass instead of copying the entire document on each substitution.
+func applyInlineRewrites(markdown string, edits []inlineRewrite) string {
+ if len(edits) == 0 {
+ return markdown
+ }
+ var b strings.Builder
+ b.Grow(len(markdown))
+ cursor := 0
+ for _, e := range edits {
+ if e.start < cursor {
+ continue
+ }
+ b.WriteString(markdown[cursor:e.start])
+ b.WriteString(e.value)
+ cursor = e.end
+ }
+ b.WriteString(markdown[cursor:])
+ return b.String()
+}
+
// ResolveHTMLDataURIImages finds <img src="data:image/*;base64,..."> tags in markdown,
// decodes the images, stores them via fileSvc, and replaces each tag with a markdown
// image reference using the storage URL.
@@ -380,32 +523,50 @@ func (r *ImageResolver) ResolveHTMLDataURIImages(
if len(matches) == 0 {
return markdown, nil, nil
}
+ codeRanges := markdownCodeLiteralRanges(markdown)
+ var rewrites []inlineRewrite
+ quota := quotaForInlineImages(ctx)
- processed := 0
- for i := len(matches) - 1; i >= 0; i-- {
- if processed >= maxRemoteImages {
- break
- }
+ for i := range matches {
m := matches[i]
+ if _, ok := codeLiteralRangeAt(codeRanges, m[0]); ok {
+ continue
+ }
dataURI := markdown[m[2]:m[3]]
mimeType, payload, ok := parseImageDataURI(dataURI)
if !ok {
+ rewrites = append(rewrites, inlineRewrite{m[0], m[1], inlineImageOmitted})
continue
}
payload = cleanBase64Payload(payload)
if payload == "" {
+ rewrites = append(rewrites, inlineRewrite{m[0], m[1], inlineImageOmitted})
+ continue
+ }
+ if oversizedInlinePayload(payload) {
+ rewrites = append(rewrites, inlineRewrite{m[0], m[1], inlineImageOmitted})
continue
}
data, decErr := decodeBase64Flexible(payload)
if decErr != nil {
log.Printf("WARN: HTML img data URI base64 decode failed: %v", decErr)
+ rewrites = append(rewrites, inlineRewrite{m[0], m[1], inlineImageOmitted})
continue
}
if len(data) > maxRemoteImageSize {
+ rewrites = append(rewrites, inlineRewrite{m[0], m[1], inlineImageOmitted})
+ continue
+ }
+ if !isCompleteInlineImage(data, mimeType) {
+ rewrites = append(rewrites, inlineRewrite{m[0], m[1], inlineImageOmitted})
continue
}
if isIconImage(data) {
- markdown = markdown[:m[0]] + markdown[m[1]:]
+ rewrites = append(rewrites, inlineRewrite{m[0], m[1], ""})
+ continue
+ }
+ if !quota.permits(len(data)) {
+ rewrites = append(rewrites, inlineRewrite{m[0], m[1], inlineImageOmitted})
continue
}
ext := extFromMime(mimeType)
@@ -415,18 +576,18 @@ func (r *ImageResolver) ResolveHTMLDataURIImages(
fileName := uuid.New().String() + ext
servingURL, saveErr := fileSvc.SaveBytes(ctx, data, tenantID, fileName, false)
if saveErr != nil {
- log.Printf("WARN: failed to save HTML img data URI image: %v", saveErr)
- continue
+ return markdown, images, fmt.Errorf("save HTML data URI image: %w", saveErr)
}
images = append(images, StoredImage{
OriginalRef: "html-img-data-uri",
ServingURL: servingURL,
MimeType: mimeType,
+ Inline: true,
})
- markdown = markdown[:m[0]] + fmt.Sprintf("![image](%s)", servingURL) + markdown[m[1]:]
- processed++
+ rewrites = append(rewrites, inlineRewrite{m[0], m[1], fmt.Sprintf("![image](%s)", servingURL)})
}
- return markdown, images, nil
+ applyMultimodalBudget(images)
+ return applyInlineRewrites(markdown, rewrites), images, nil
}
// ResolveRelativeHTMLImages finds HTML <img> tags whose src points at a
@@ -470,12 +631,633 @@ func (r *ImageResolver) ResolveRelativeHTMLImages(
// bareDataURIPattern matches standalone data:image/*;base64,... strings.
var bareDataURIPattern = regexp.MustCompile(
- `(?i)data:image/([^;\s]+);base64,([A-Za-z0-9+/=]{100,})`,
+ `(?i)data:image/([^;\s]+);base64,[ \t\r\n]*([^\r\n\s"'<>)]{1,})`,
)
// bareBase64CommaPrefixed matches base64,DATA patterns (partial data URIs missing the mime prefix).
var bareBase64CommaPrefixed = regexp.MustCompile(
- `base64,([A-Za-z0-9+/=]{200,})`,
+ `base64,[ \t\r\n]*([^\r\n\s"'<>)]{32,})`,
+)
+
+const wrappedBase64LineLength = 76
+
+// wrappedBase64PayloadEnd extends a payload over Base64 fragments separated by newlines.
+// Width is not a boundary: encoding syntax and a complete image determine the end.
+// On failure the returned end stays on the first line. Callers must reject an
+// ambiguous continuation rather than erase its prefix and allow the tail through.
+// supported is true only after full validation within the decode budget.
+// Decoded data never grows beyond the existing single-image cap.
+func wrappedBase64PayloadEnd(markdown string, payloadStart, payloadEnd int) (end int, complete, supported bool) {
+ // Sentence punctuation belongs to the document, including after damaged tokens.
+ firstLine := strings.TrimRight(markdown[payloadStart:payloadEnd], ".,;")
+ payloadEnd = payloadStart + len(firstLine)
+ if len(firstLine) < 32 && !looksLikeImageBase64(firstLine) {
+ return payloadEnd, true, false
+ }
+ if !isStrictBase64Line(firstLine) || oversizedInlinePayload(firstLine) {
+ return payloadEnd, false, false
+ }
+ // Keep partial encoding groups across line breaks, which need not align
+ // with Base64's four-character groups.
+ pending := firstLine[len(firstLine)/4*4:]
+ imageData, err := decodeBase64Flexible(firstLine[:len(firstLine)/4*4])
+ if err != nil {
+ return payloadEnd, false, false
+ }
+ imageValidity := func() (complete, supported bool) {
+ data := imageData
+ if pending != "" {
+ tail, err := decodeBase64Flexible(pending)
+ if err != nil || len(tail) > maxRemoteImageSize-len(data) {
+ return false, false
+ }
+ data = append(data, tail...)
+ }
+ return validateInlineImageData(data)
+ }
+ if complete, supported := imageValidity(); complete {
+ return payloadEnd, true, supported
+ }
+
+ currentEnd := payloadEnd
+ binaryImage := sniffImageMime(imageData) != ""
+ // Cache the opening element boundary. A self-closing root can end on a
+ // full encoded line; child /> tags must not trigger repeated XML validation.
+ svgOpeningEnd := -1
+ for {
+ lineStart := currentEnd
+ if lineStart < len(markdown) && markdown[lineStart] == '\r' {
+ lineStart++
+ }
+ if lineStart >= len(markdown) || markdown[lineStart] != '\n' {
+ return payloadEnd, false, false
+ }
+ lineStart++
+ lineEnd := strings.IndexByte(markdown[lineStart:], '\n')
+ if lineEnd < 0 {
+ lineEnd = len(markdown)
+ } else {
+ lineEnd += lineStart
+ }
+ candidateEnd := lineEnd
+ if candidateEnd > lineStart && markdown[candidateEnd-1] == '\r' {
+ candidateEnd--
+ }
+ linePayloadEnd := candidateEnd
+ fragment := markdown[lineStart:candidateEnd]
+ if boundary := strings.IndexAny(fragment, " \t\"'<>)]"); boundary >= 0 {
+ fragment = fragment[:boundary]
+ }
+ fragment = strings.TrimRight(fragment, ".,;")
+ candidateEnd = lineStart + len(fragment)
+ line := fragment
+ if len(line) == 0 || !isStrictBase64Line(line) {
+ return payloadEnd, false, false
+ }
+ if oversizedInlinePayload(line) {
+ return payloadEnd, false, false
+ }
+ encoded := pending + line
+ end := len(encoded) / 4 * 4
+ pending = encoded[end:]
+ lineData, err := decodeBase64Flexible(encoded[:end])
+ if err != nil {
+ return payloadEnd, false, false
+ }
+ if len(lineData) > maxRemoteImageSize-len(imageData) {
+ return payloadEnd, false, false
+ }
+ needed := len(imageData) + len(lineData)
+ if needed > cap(imageData) {
+ grown := make([]byte, len(imageData), min(maxRemoteImageSize, max(needed, 2*cap(imageData))))
+ copy(grown, imageData)
+ imageData = grown
+ }
+ imageData = append(imageData, lineData...)
+ tail := bytes.TrimSpace(imageData[max(0, len(imageData)-64):])
+ if !binaryImage && svgOpeningEnd < 0 && bytes.HasSuffix(tail, []byte("/>")) {
+ decoder := xml.NewDecoder(bytes.NewReader(imageData))
+ for {
+ token, err := decoder.Token()
+ if err != nil {
+ break
+ }
+ if _, ok := token.(xml.StartElement); ok {
+ svgOpeningEnd = int(decoder.InputOffset())
+ break
+ }
+ }
+ }
+ selfClosingRoot := svgOpeningEnd >= 2 &&
+ bytes.Equal(imageData[svgOpeningEnd-2:svgOpeningEnd], []byte("/>")) &&
+ len(bytes.TrimSpace(imageData[svgOpeningEnd:])) == 0
+ if binaryImage || candidateEnd < linePayloadEnd || strings.Contains(line, "=") || len(line)%4 != 0 ||
+ bytes.HasSuffix(tail, []byte("</svg>")) || selfClosingRoot {
+ if complete, supported := imageValidity(); complete {
+ return candidateEnd, true, supported
+ }
+ }
+ if candidateEnd < linePayloadEnd || (strings.Contains(line, "=") && pending == "") {
+ return payloadEnd, false, false
+ }
+ currentEnd = candidateEnd
+ }
+}
+
+// ErrAmbiguousInlineImage means the image cannot be separated from following
+// lines without guessing. Callers should keep the source and stop ingestion.
+var ErrAmbiguousInlineImage = errors.New(
+ "cannot determine the end of a malformed multiline inline image; repair or remove the image")
+
+func hasInlineImageContinuation(markdown string, end int) bool {
+ rest := strings.TrimLeft(markdown[end:], " \t\r")
+ if !strings.HasPrefix(rest, "\n") {
+ return false
+ }
+ line, _, _ := strings.Cut(rest[1:], "\n")
+ line = strings.TrimSpace(line)
+ if line == "" || markdownATXHeading.MatchString(line) {
+ return false
+ }
+ // A non-ASCII letter establishes a prose start. ASCII text and corrupt
+ // prefixes such as !AAAA remain ambiguous; do not leave their tails behind.
+ first, _ := utf8.DecodeRuneInString(line)
+ return first < utf8.RuneSelf || !unicode.IsLetter(first)
+}
+
+func isStrictBase64Line(line string) bool {
+ for i := 0; i < len(line); i++ {
+ c := line[i]
+ if (c >= 'A' && c <= 'Z') || (c >= 'a' && c <= 'z') || (c >= '0' && c <= '9') ||
+ c == '+' || c == '/' || c == '_' || c == '-' || c == '=' {
+ continue
+ }
+ return false
+ }
+ return true
+}
+
+const (
+ // Fixed support limits for inline raster images bound decoding memory.
+ // Even valid images over 16,777,216 pixels are omitted; this is not corruption.
+ // GIFs also have aggregate pixel and frame limits.
+ maxInlineImagePixels = 16 * 1024 * 1024
+ maxInlineGIFPixels = 32 * 1024 * 1024
+ maxInlineGIFFrames = 256
+)
+
+func isCompleteInlineImage(data []byte, mimeType string) bool {
+ // A declared image MIME type alone cannot validate unrecognized bytes.
+ if extFromMime(mimeType) == "" && sniffInlineImageMime(data) == "" {
+ return false
+ }
+ _, supported := validateInlineImageData(data)
+ return supported
+}
+
+// validateInlineImageData distinguishes a complete boundary from permission to store.
+// Over-budget containers with an end boundary may be omitted without decoding
+// their pixels. Only images that pass full validation are supported for storage.
+func validateInlineImageData(data []byte) (complete, supported bool) {
+ mimeType := sniffImageMime(data)
+ // Header checks allocate decoder buffers too: run them only once an image
+ // boundary is present, rather than for every fragment of a truncated payload.
+ switch mimeType {
+ case "image/png":
+ complete = bytes.HasSuffix(data, []byte{0, 0, 0, 0, 'I', 'E', 'N', 'D', 0xAE, 0x42, 0x60, 0x82})
+ case "image/jpeg":
+ complete = bytes.HasSuffix(data, []byte{0xFF, 0xD9})
+ case "image/gif":
+ complete = len(data) > 0 && data[len(data)-1] == ';'
+ case "image/webp":
+ complete = len(data) >= 12 && uint64(binary.LittleEndian.Uint32(data[4:8]))+8 == uint64(len(data))
+ case "image/bmp":
+ complete = len(data) >= 6 && uint64(binary.LittleEndian.Uint32(data[2:6])) == uint64(len(data))
+ }
+ if mimeType != "" {
+ if !complete {
+ return false, false
+ }
+ cfg, _, err := image.DecodeConfig(bytes.NewReader(data))
+ if err != nil || cfg.Width <= 0 || cfg.Height <= 0 {
+ return false, false
+ }
+ withinBudget := uint64(cfg.Width) <= maxInlineImagePixels/uint64(cfg.Height)
+ if mimeType == "image/gif" {
+ valid, framesWithinBudget := gifDecodeBudget(data)
+ if !valid {
+ return false, false
+ }
+ withinBudget = withinBudget && framesWithinBudget
+ }
+ if !withinBudget {
+ log.Printf("WARN: inline %s image %dx%d exceeds supported decode budget; omitted",
+ mimeType, cfg.Width, cfg.Height)
+ return true, false
+ }
+ if mimeType == "image/gif" {
+ _, err = gif.DecodeAll(bytes.NewReader(data))
+ } else {
+ _, _, err = image.Decode(bytes.NewReader(data))
+ }
+ return err == nil, err == nil
+ }
+ decoder := xml.NewDecoder(bytes.NewReader(data))
+ depth, roots := 0, 0
+ for {
+ token, err := decoder.Token()
+ if err == io.EOF {
+ valid := roots == 1 && depth == 0
+ return valid, valid
+ }
+ if err != nil {
+ return false, false
+ }
+ switch token := token.(type) {
+ case xml.StartElement:
+ if depth == 0 {
+ roots++
+ if roots != 1 || token.Name.Local != "svg" {
+ return false, false
+ }
+ }
+ depth++
+ case xml.EndElement:
+ depth--
+ case xml.CharData:
+ if depth == 0 && len(bytes.TrimSpace(token)) != 0 {
+ return false, false
+ }
+ }
+ }
+}
+
+// gifDecodeBudget checks the frame envelope before bounded LZW validation.
+func gifDecodeBudget(data []byte) (valid, withinBudget bool) {
+ if len(data) < 13 {
+ return false, false
+ }
+ offset := 13
+ if data[10]&0x80 != 0 {
+ offset += 3 << (1 + (data[10] & 7))
+ }
+ frames, pixels := 0, uint64(0)
+ skipBlocks := func() bool {
+ for offset < len(data) {
+ size := int(data[offset])
+ offset++
+ if size == 0 {
+ return true
+ }
+ if size > len(data)-offset {
+ return false
+ }
+ offset += size
+ }
+ return false
+ }
+ for offset < len(data) {
+ block := data[offset]
+ offset++
+ switch block {
+ case 0x3B:
+ return frames > 0 && offset == len(data), frames <= maxInlineGIFFrames && pixels <= maxInlineGIFPixels
+ case 0x21:
+ if offset >= len(data) {
+ return false, false
+ }
+ offset++ // Extension label; its data uses the same sub-block envelope.
+ if !skipBlocks() {
+ return false, false
+ }
+ case 0x2C:
+ if len(data)-offset < 9 {
+ return false, false
+ }
+ descriptor := data[offset : offset+9]
+ width := uint64(binary.LittleEndian.Uint16(descriptor[4:6]))
+ height := uint64(binary.LittleEndian.Uint16(descriptor[6:8]))
+ pixels += width * height
+ frames++
+ if width == 0 || height == 0 {
+ return false, false
+ }
+ offset += 9
+ if descriptor[8]&0x80 != 0 {
+ offset += 3 << (1 + (descriptor[8] & 7))
+ }
+ if offset >= len(data) {
+ return false, false
+ }
+ offset++ // LZW minimum code size.
+ if !skipBlocks() {
+ return false, false
+ }
+ default:
+ return false, false
+ }
+ }
+ return false, false
+}
+
+// HasUnresolvedInlineImagePayload guards the chunking boundary against data
+// URIs that a parser could not recognize or resolve. It deliberately ignores
+// ordinary prose mentioning base64 and non-image base64 examples.
+func HasUnresolvedInlineImagePayload(markdown string) bool {
+ if !containsBase64Marker(markdown) {
+ return false
+ }
+ markdown = withoutMarkdownCodeLiterals(markdown)
+ for _, match := range unresolvedImageDataURI.FindAllString(markdown, -1) {
+ if idx := strings.Index(strings.ToLower(match), "base64,"); idx >= 0 &&
+ looksLikeImageBase64(strings.TrimSpace(match[idx+len("base64,"):])) {
+ return true
+ }
+ }
+ for _, match := range unresolvedBareBase64Image.FindAllStringSubmatch(markdown, -1) {
+ if looksLikeImageBase64(match[1]) {
+ return true
+ }
+ }
+ return false
+}
+
+func containsBase64Marker(markdown string) bool {
+ const marker = "base64,"
+ for i := 0; i+len(marker) <= len(markdown); i++ {
+ if markdown[i] != 'b' && markdown[i] != 'B' {
+ continue
+ }
+ if strings.EqualFold(markdown[i:i+len(marker)], marker) {
+ return true
+ }
+ }
+ return false
+}
+
+type markdownCodeLiteralRange struct {
+ start int
+ end int
+}
+
+// withoutMarkdownCodeLiterals masks fenced and inline code while preserving
+// byte offsets. The image resolver uses the same ranges before replacing a
+// match, so documentation snippets cannot be either uploaded or rejected.
+func withoutMarkdownCodeLiterals(markdown string) string {
+ ranges := markdownCodeLiteralRanges(markdown)
+ if len(ranges) == 0 {
+ return markdown
+ }
+ masked := []byte(markdown)
+ for _, r := range ranges {
+ for i := r.start; i < r.end; i++ {
+ if masked[i] != '\n' {
+ masked[i] = ' '
+ }
+ }
+ }
+ return string(masked)
+}
+
+// Literal code containers must not be interpreted as image references.
+var (
+ htmlCodeLiteralPattern = regexp.MustCompile(`(?is)<pre\b[^>]*>.*?</pre\s*>|<code\b[^>]*>.*?</code\s*>`)
+ markdownListItemPrefix = regexp.MustCompile(`^(?:[-*+]|[0-9]+[.)])[ \t]`)
+ markdownATXHeading = regexp.MustCompile(`^#{1,6}(?:[ \t]|$)`)
+)
+
+// indentedCodeLiteralRanges identifies indented code and list content in one
+// forward scan. A list child may have four leading spaces and still contain a
+// normal image, while four more spaces beyond its content indent introduce code.
+func indentedCodeLiteralRanges(markdown string, blocks []markdownCodeLiteralRange) []markdownCodeLiteralRange {
+ var ranges []markdownCodeLiteralRange
+ var listContentIndent int
+ hasListItem := false
+ blankLines := 0
+ inParagraph := false
+
+ for lineStart := 0; lineStart < len(markdown); {
+ lineEnd := strings.IndexByte(markdown[lineStart:], '\n')
+ if lineEnd < 0 {
+ lineEnd = len(markdown)
+ } else {
+ lineEnd += lineStart
+ }
+ line := markdown[lineStart:lineEnd]
+ indent := len(line) - len(strings.TrimLeft(line, " \t"))
+ trimmed := strings.TrimSpace(line)
+
+ // An indented code block cannot interrupt an existing paragraph.
+ indentedCode := strings.HasPrefix(line, "\t") || indent >= 4
+ if _, inBlock := codeLiteralRangeAt(blocks, lineStart); inBlock {
+ inParagraph = false
+ } else if indentedCode && !inParagraph && (!hasListItem || blankLines >= 2 || indent >= listContentIndent) {
+ ranges = append(ranges, markdownCodeLiteralRange{start: lineStart, end: lineEnd})
+ } else {
+ inParagraph = trimmed != "" && !markdownATXHeading.MatchString(trimmed)
+ }
+
+ if trimmed == "" {
+ blankLines++
+ if blankLines >= 2 {
+ hasListItem = false
+ }
+ } else {
+ if marker := markdownListItemPrefix.FindString(trimmed); marker != "" {
+ blankLines = 0
+ listContentIndent = indent + len(marker) + 4
+ hasListItem = true
+ } else if indent == 0 {
+ hasListItem = false
+ }
+ }
+
+ if lineEnd == len(markdown) {
+ break
+ }
+ lineStart = lineEnd + 1
+ }
+ return ranges
+}
+
+func mergeCodeLiteralRanges(ranges []markdownCodeLiteralRange) []markdownCodeLiteralRange {
+ sort.Slice(ranges, func(i, j int) bool { return ranges[i].start < ranges[j].start })
+ merged := make([]markdownCodeLiteralRange, 0, len(ranges))
+ for _, span := range ranges {
+ if len(merged) > 0 && span.start <= merged[len(merged)-1].end {
+ if span.end > merged[len(merged)-1].end {
+ merged[len(merged)-1].end = span.end
+ }
+ continue
+ }
+ merged = append(merged, span)
+ }
+ return merged
+}
+
+func markdownCodeLiteralRanges(markdown string) []markdownCodeLiteralRange {
+ protected := fencedCodeLiteralRanges(markdown)
+ for _, match := range htmlCodeLiteralPattern.FindAllStringIndex(markdown, -1) {
+ protected = append(protected, markdownCodeLiteralRange{start: match[0], end: match[1]})
+ }
+ protected = mergeCodeLiteralRanges(protected)
+ protected = append(protected, indentedCodeLiteralRanges(markdown, protected)...)
+ protected = mergeCodeLiteralRanges(protected)
+ var inline []markdownCodeLiteralRange
+ for i := 0; i < len(markdown); {
+ if end, ok := codeLiteralRangeAt(protected, i); ok {
+ i = end
+ continue
+ }
+ if markdown[i] != '`' || isEscaped(markdown, i) {
+ i++
+ continue
+ }
+ runLength := 1
+ for i+runLength < len(markdown) && markdown[i+runLength] == '`' {
+ runLength++
+ }
+ closePos := findInlineCodeLiteralClose(markdown, protected, i+runLength, runLength)
+ if closePos < 0 {
+ i += runLength
+ continue
+ }
+ inline = append(inline, markdownCodeLiteralRange{start: i, end: closePos + runLength})
+ i = closePos + runLength
+ }
+ return mergeCodeLiteralRanges(append(protected, inline...))
+}
+
+func fencedCodeLiteralRanges(markdown string) []markdownCodeLiteralRange {
+ var ranges []markdownCodeLiteralRange
+ var fence byte
+ var fenceLength, fenceStart, fenceQuoteDepth int
+
+ for lineStart := 0; lineStart < len(markdown); {
+ lineEnd := strings.IndexByte(markdown[lineStart:], '\n')
+ if lineEnd < 0 {
+ lineEnd = len(markdown)
+ } else {
+ lineEnd += lineStart
+ }
+ line := markdown[lineStart:lineEnd]
+ trimmed := strings.TrimLeft(line, " \t")
+ quoteDepth := 0
+ for strings.HasPrefix(trimmed, ">") {
+ quoteDepth++
+ trimmed = strings.TrimLeft(trimmed[1:], " \t")
+ }
+ // A quoted fence ends with its container, even if it is unclosed.
+ if fence != 0 && quoteDepth < fenceQuoteDepth {
+ ranges = append(ranges, markdownCodeLiteralRange{start: fenceStart, end: lineStart})
+ fence = 0
+ }
+ if fence == 0 {
+ if marker, length := codeFence(trimmed); length > 0 {
+ fence, fenceLength, fenceStart, fenceQuoteDepth = marker, length, lineStart, quoteDepth
+ }
+ } else if marker, length := codeFence(trimmed); quoteDepth == fenceQuoteDepth &&
+ marker == fence && length >= fenceLength &&
+ strings.TrimSpace(trimmed[length:]) == "" {
+ end := lineEnd
+ if end < len(markdown) {
+ end++
+ }
+ ranges = append(ranges, markdownCodeLiteralRange{start: fenceStart, end: end})
+ fence, fenceLength = 0, 0
+ }
+ if lineEnd == len(markdown) {
+ break
+ }
+ lineStart = lineEnd + 1
+ }
+ if fence != 0 {
+ ranges = append(ranges, markdownCodeLiteralRange{start: fenceStart, end: len(markdown)})
+ }
+ return ranges
+}
+
+func codeLiteralRangeAt(ranges []markdownCodeLiteralRange, offset int) (int, bool) {
+ index := sort.Search(len(ranges), func(i int) bool { return ranges[i].end > offset })
+ if index < len(ranges) && ranges[index].start <= offset {
+ return ranges[index].end, true
+ }
+ return 0, false
+}
+
+func findInlineCodeLiteralClose(markdown string, ranges []markdownCodeLiteralRange, start, runLength int) int {
+ for i := start; i < len(markdown); {
+ if end, ok := codeLiteralRangeAt(ranges, i); ok {
+ // Inline HTML does not terminate the surrounding Markdown code span.
+ if strings.EqualFold(markdown[i:min(i+5, len(markdown))], "<code") {
+ i = end
+ continue
+ }
+ return -1
+ }
+ if markdown[i] == '\n' {
+ next := i + 1
+ for next < len(markdown) && (markdown[next] == ' ' || markdown[next] == '\t' || markdown[next] == '\r') {
+ next++
+ }
+ if next < len(markdown) && markdown[next] == '\n' {
+ return -1
+ }
+ }
+ if markdown[i] != '`' {
+ i++
+ continue
+ }
+ end := i
+ for end < len(markdown) && markdown[end] == '`' {
+ end++
+ }
+ if end-i == runLength {
+ return i
+ }
+ i = end
+ }
+ return -1
+}
+
+func codeFence(line string) (byte, int) {
+ if len(line) < 3 || (line[0] != '`' && line[0] != '~') {
+ return 0, 0
+ }
+ marker := line[0]
+ length := 0
+ for length < len(line) && line[length] == marker {
+ length++
+ }
+ if length < 3 {
+ return 0, 0
+ }
+ return marker, length
+}
+
+func looksLikeImageBase64(payload string) bool {
+ // A short prefix is sufficient for binary magic, but not for an SVG root.
+ header, err := decodeBase64Flexible(payload[:min(len(payload), 64)])
+ if err == nil && sniffImageMime(header) != "" {
+ return true
+ }
+ // Even the guard must not allocate more than the single-image limit.
+ limit := (maxRemoteImageSize / 3) * 4
+ data, err := decodeBase64Flexible(payload[:min(len(payload), limit)])
+ if err != nil {
+ return false
+ }
+ if sniffInlineImageMime(data) != "" {
+ return true
+ }
+ // The guard can also recognize a root start split across wrapped lines.
+ trimmed := bytes.TrimSpace(data)
+ return bytes.HasPrefix(trimmed, []byte("<svg ")) || bytes.HasPrefix(trimmed, []byte("<svg>"))
+}
+
+var (
+ unresolvedImageDataURI = regexp.MustCompile(`(?i)data:image/[^;\s"'<>)]*;base64,\s*[^\s"'<>)]{1,}`)
+ unresolvedBareBase64Image = regexp.MustCompile(`(?i)base64,([A-Za-z0-9+/_=-]{64,})`)
)
// ResolveBareBase64Content finds remaining bare data URIs and base64 image content
@@ -487,13 +1269,23 @@ func (r *ImageResolver) ResolveBareBase64Content(
fileSvc interfaces.FileService,
tenantID uint64,
) (updatedMarkdown string, images []StoredImage, err error) {
- md, imgs1 := r.resolveBareDataURIs(ctx, markdown, fileSvc, tenantID)
- markdown = md
+ originalMarkdown := markdown
+ if _, ok := ctx.Value(inlineQuotaKey{}).(*inlineQuota); !ok {
+ ctx = context.WithValue(ctx, inlineQuotaKey{}, &inlineQuota{})
+ }
+ md, imgs1, err := r.resolveBareDataURIs(ctx, markdown, fileSvc, tenantID, markdownCodeLiteralRanges(markdown))
images = append(images, imgs1...)
+ if err != nil {
+ return originalMarkdown, images, err
+ }
+ markdown = md
- md2, imgs2 := r.resolveBareBase64Prefix(ctx, markdown, fileSvc, tenantID)
- markdown = md2
+ md2, imgs2, err := r.resolveBareBase64Prefix(ctx, markdown, fileSvc, tenantID, markdownCodeLiteralRanges(markdown))
images = append(images, imgs2...)
+ if err != nil {
+ return originalMarkdown, images, err
+ }
+ markdown = md2
return markdown, images, nil
}
@@ -503,48 +1295,82 @@ func (r *ImageResolver) resolveBareDataURIs(
markdown string,
fileSvc interfaces.FileService,
tenantID uint64,
-) (string, []StoredImage) {
+ codeRanges []markdownCodeLiteralRange,
+) (string, []StoredImage, error) {
matches := bareDataURIPattern.FindAllStringSubmatchIndex(markdown, -1)
if len(matches) == 0 {
- return markdown, nil
+ return markdown, nil, nil
}
var images []StoredImage
- processed := 0
- for i := len(matches) - 1; i >= 0; i-- {
- if processed >= maxRemoteImages {
- break
- }
+ var rewrites []inlineRewrite
+ quota := quotaForInlineImages(ctx)
+ for i := range matches {
m := matches[i]
- // Check context: skip HTML src attributes, but handle broken markdown refs
+ if _, ok := codeLiteralRangeAt(codeRanges, m[0]); ok {
+ continue
+ }
+ // Well-formed HTML images were handled above. Quoted leftovers may
+ // be malformed attributes and still need local resolution or omission.
insideWrapper := false
if m[0] > 0 {
prev := markdown[m[0]-1]
- if prev == '"' || prev == '\'' {
- continue // inside HTML attribute — already handled by ResolveHTMLDataURIImages
- }
- if prev == '(' {
+ insideWrapper = prev == '"' || prev == '\''
+ if prev == '(' || (prev == '<' && m[0] >= 2 && markdown[m[0]-2] == '(') {
insideWrapper = true // likely inside a broken ![...](...) ref
}
}
- mimeSubtype := strings.ToLower(markdown[m[2]:m[3]])
+ mimeType := "image/" + strings.ToLower(markdown[m[2]:m[3]])
+ payloadEnd, complete, supported := m[5], true, false
+ if extFromMime(mimeType) != "" || looksLikeImageBase64(markdown[m[4]:m[5]]) {
+ payloadEnd, complete, supported = wrappedBase64PayloadEnd(markdown, m[4], m[5])
+ }
+ if !complete {
+ if hasInlineImageContinuation(markdown, payloadEnd) {
+ return markdown, images, ErrAmbiguousInlineImage
+ }
+ rewrites = append(rewrites, inlineRewrite{m[0], payloadEnd, inlineImageOmitted})
+ continue
+ }
+ m[1], m[5] = payloadEnd, payloadEnd
payload := markdown[m[4]:m[5]]
- mimeType := "image/" + mimeSubtype
payload = cleanBase64Payload(payload)
if payload == "" {
+ rewrites = append(rewrites, inlineRewrite{m[0], m[1], inlineImageOmitted})
+ continue
+ }
+ if oversizedInlinePayload(payload) {
+ rewrites = append(rewrites, inlineRewrite{m[0], m[1], inlineImageOmitted})
continue
}
data, decErr := decodeBase64Flexible(payload)
if decErr != nil {
- log.Printf("WARN: bare data URI base64 decode failed: %v", decErr)
+ // Preserve short explanatory data-URI examples instead of treating
+ // them as actual broken images.
+ if len(payload) >= 64 {
+ log.Printf("WARN: bare data URI base64 decode failed: %v", decErr)
+ rewrites = append(rewrites, inlineRewrite{m[0], m[1], inlineImageOmitted})
+ }
continue
}
if len(data) > maxRemoteImageSize {
+ rewrites = append(rewrites, inlineRewrite{m[0], m[1], inlineImageOmitted})
+ continue
+ }
+ if sniffInlineImageMime(data) == "" && mimeType != "image/svg+xml" && len(payload) < 100 {
+ continue // not a real image, e.g. a short unquoted tutorial example
+ }
+ if !supported {
+ rewrites = append(rewrites, inlineRewrite{m[0], m[1], inlineImageOmitted})
continue
}
if isIconImage(data) {
- markdown = markdown[:m[0]] + markdown[m[1]:]
+ rewrites = append(rewrites, inlineRewrite{m[0], m[1], ""})
+ continue
+ }
+ if !quota.permits(len(data)) {
+ rewrites = append(rewrites, inlineRewrite{m[0], m[1], inlineImageOmitted})
continue
}
ext := extFromMime(mimeType)
@@ -554,23 +1380,23 @@ func (r *ImageResolver) resolveBareDataURIs(
fileName := uuid.New().String() + ext
servingURL, saveErr := fileSvc.SaveBytes(ctx, data, tenantID, fileName, false)
if saveErr != nil {
- log.Printf("WARN: failed to save bare data URI image: %v", saveErr)
- continue
+ return markdown, images, fmt.Errorf("save bare data URI image: %w", saveErr)
}
images = append(images, StoredImage{
OriginalRef: "bare-data-uri",
ServingURL: servingURL,
MimeType: mimeType,
+ Inline: true,
})
if insideWrapper {
// Inside a broken markdown ref like ![weird]alt](data:...) — replace data URI only
- markdown = markdown[:m[0]] + servingURL + markdown[m[1]:]
+ rewrites = append(rewrites, inlineRewrite{m[0], m[1], servingURL})
} else {
- markdown = markdown[:m[0]] + fmt.Sprintf("![image](%s)", servingURL) + markdown[m[1]:]
+ rewrites = append(rewrites, inlineRewrite{m[0], m[1], fmt.Sprintf("![image](%s)", servingURL)})
}
- processed++
}
- return markdown, images
+ applyMultimodalBudget(images)
+ return applyInlineRewrites(markdown, rewrites), images, nil
}
func (r *ImageResolver) resolveBareBase64Prefix(
@@ -578,41 +1404,72 @@ func (r *ImageResolver) resolveBareBase64Prefix(
markdown string,
fileSvc interfaces.FileService,
tenantID uint64,
-) (string, []StoredImage) {
+ codeRanges []markdownCodeLiteralRange,
+) (string, []StoredImage, error) {
matches := bareBase64CommaPrefixed.FindAllStringSubmatchIndex(markdown, -1)
if len(matches) == 0 {
- return markdown, nil
+ return markdown, nil, nil
}
var images []StoredImage
- processed := 0
- for i := len(matches) - 1; i >= 0; i-- {
- if processed >= maxRemoteImages {
- break
- }
+ var rewrites []inlineRewrite
+ quota := quotaForInlineImages(ctx)
+ for i := range matches {
m := matches[i]
+ if _, ok := codeLiteralRangeAt(codeRanges, m[0]); ok {
+ continue
+ }
// Skip if preceded by ';' — this is part of a data URI handled above
if m[0] > 0 && markdown[m[0]-1] == ';' {
continue
}
+ payloadEnd, complete, supported := wrappedBase64PayloadEnd(markdown, m[2], m[3])
+ if !complete && hasInlineImageContinuation(markdown, payloadEnd) &&
+ looksLikeImageBase64(markdown[m[2]:m[3]]) {
+ return markdown, images, ErrAmbiguousInlineImage
+ }
+ m[1], m[3] = payloadEnd, payloadEnd
payload := markdown[m[2]:m[3]]
payload = cleanBase64Payload(payload)
if payload == "" {
continue
}
+ if oversizedInlinePayload(payload) {
+ if !looksLikeImageBase64(payload) {
+ continue
+ }
+ rewrites = append(rewrites, inlineRewrite{m[0], m[1], inlineImageOmitted})
+ continue
+ }
data, decErr := decodeBase64Flexible(payload)
if decErr != nil {
+ if !looksLikeImageBase64(payload) {
+ continue
+ }
+ rewrites = append(rewrites, inlineRewrite{m[0], m[1], inlineImageOmitted})
continue
}
if len(data) > maxRemoteImageSize {
+ rewrites = append(rewrites, inlineRewrite{m[0], m[1], inlineImageOmitted})
continue
}
- mimeType := sniffImageMime(data)
+ mimeType := sniffInlineImageMime(data)
if mimeType == "" {
+ if looksLikeImageBase64(payload) {
+ rewrites = append(rewrites, inlineRewrite{m[0], m[1], inlineImageOmitted})
+ }
+ continue
+ }
+ if !supported {
+ rewrites = append(rewrites, inlineRewrite{m[0], m[1], inlineImageOmitted})
continue
}
if isIconImage(data) {
- markdown = markdown[:m[0]] + markdown[m[1]:]
+ rewrites = append(rewrites, inlineRewrite{m[0], m[1], ""})
+ continue
+ }
+ if !quota.permits(len(data)) {
+ rewrites = append(rewrites, inlineRewrite{m[0], m[1], inlineImageOmitted})
continue
}
ext := extFromMime(mimeType)
@@ -622,18 +1479,18 @@ func (r *ImageResolver) resolveBareBase64Prefix(
fileName := uuid.New().String() + ext
servingURL, saveErr := fileSvc.SaveBytes(ctx, data, tenantID, fileName, false)
if saveErr != nil {
- log.Printf("WARN: failed to save bare base64 image: %v", saveErr)
- continue
+ return markdown, images, fmt.Errorf("save bare base64 image: %w", saveErr)
}
images = append(images, StoredImage{
OriginalRef: "bare-base64",
ServingURL: servingURL,
MimeType: mimeType,
+ Inline: true,
})
- markdown = markdown[:m[0]] + fmt.Sprintf("![image](%s)", servingURL) + markdown[m[1]:]
- processed++
+ rewrites = append(rewrites, inlineRewrite{m[0], m[1], fmt.Sprintf("![image](%s)", servingURL)})
}
- return markdown, images
+ applyMultimodalBudget(images)
+ return applyInlineRewrites(markdown, rewrites), images, nil
}
// ---------------------------------------------------------------------------
@@ -645,10 +1502,24 @@ const (
maxRemoteImageSize = 10 * 1024 * 1024 // 10 MB
// maxRemoteImages is the maximum number of remote images to process per document.
maxRemoteImages = 30
+ // maxInlineImagesForMultimodal is the legacy per-syntax number of inline
+ // images that reach image understanding. Additional inline images are saved
+ // and bound, but do not fan out OCR/caption work.
+ maxInlineImagesForMultimodal = 30
// remoteImageFetchTimeout is the per-image HTTP request timeout.
remoteImageFetchTimeout = 15 * time.Second
)
+// applyMultimodalBudget flags images beyond the per-syntax AI quota.
+// Inline resolvers visit matches in document order and construct text in one pass,
+// the document's leading maxInlineImagesForMultimodal go to AI understanding,
+// the rest stay stored and bound but skip OCR/caption fan-out.
+func applyMultimodalBudget(images []StoredImage) {
+ for i := range images {
+ images[i].SkipMultimodal = i >= maxInlineImagesForMultimodal
+ }
+}
+
// reLinkedImage matches the nested [![alt](img_url)](link_url) pattern where
// an image is wrapped inside a Markdown link. We unwrap it to just ![alt](img_url)
// so that downstream image-processing regexes only have to handle the flat form.
@@ -663,7 +1534,20 @@ var reLinkedImage = regexp.MustCompile(
// This should be called before any image-extraction regex so that only the
// flat ![alt](url) form needs to be handled.
func UnwrapLinkedImages(markdown string) string {
- return reLinkedImage.ReplaceAllString(markdown, "![$1]($2)")
+ matches := reLinkedImage.FindAllStringSubmatchIndex(markdown, -1)
+ if len(matches) == 0 {
+ return markdown
+ }
+ codeRanges := markdownCodeLiteralRanges(markdown)
+ var rewrites []inlineRewrite
+ for _, match := range matches {
+ if _, ok := codeLiteralRangeAt(codeRanges, match[0]); !ok {
+ rewrites = append(rewrites, inlineRewrite{
+ match[0], match[1], markdown[match[0]+1 : match[5]+1],
+ })
+ }
+ }
+ return applyInlineRewrites(markdown, rewrites)
}
// imgMarkdownPattern matches Markdown image syntax: ![alt](url).
@@ -672,14 +1556,6 @@ func UnwrapLinkedImages(markdown string) string {
// like https://example.com/item_(abc)/123 are captured in full.
var imgMarkdownPattern = regexp.MustCompile(`!\[(.*?)\]\(([^()\s]*(?:\([^)]*\)[^()\s]*)*)\)`)
-// imgMarkdownDataURI matches markdown images whose URL is a data:image/*;base64,...
-// payload. (?i) applies to the whole parenthesized data URI.
-// The alt-text group uses .*? (non-greedy) to allow literal ] inside alt text
-// (e.g. file paths like ![C:\img]name.png](data:...)).
-var imgMarkdownDataURI = regexp.MustCompile(
- `!\[(.*?)\]\((?i:(data:image/[^;]+;base64,\s*[^)]+))\)`,
-)
-
// parseImageDataURI splits a data URI into image MIME type and base64 payload.
func parseImageDataURI(dataURI string) (mimeType string, b64Payload string, ok bool) {
const sep = ";base64,"
@@ -702,8 +1578,8 @@ func parseImageDataURI(dataURI string) (mimeType string, b64Payload string, ok b
}
// ResolveDataURIImages finds embedded data:image/*;base64 images in markdown,
-// decodes them, stores via fileSvc, and replaces each reference with the returned
-// provider URL (same limits as remote images: count and decoded size).
+// decodes and stores each valid image, and replaces each reference with the
+// returned provider URL. A per-image decoded-size limit still applies.
func (r *ImageResolver) ResolveDataURIImages(
ctx context.Context,
markdown string,
@@ -711,40 +1587,70 @@ func (r *ImageResolver) ResolveDataURIImages(
tenantID uint64,
) (updatedMarkdown string, images []StoredImage, err error) {
markdown = UnwrapLinkedImages(markdown)
- matches := imgMarkdownDataURI.FindAllStringSubmatchIndex(markdown, -1)
+ matches := scanMarkdownImageTargets(markdown)
if len(matches) == 0 {
return markdown, nil, nil
}
+ codeRanges := markdownCodeLiteralRanges(markdown)
+ var rewrites []inlineRewrite
+ quota := quotaForInlineImages(ctx)
- processed := 0
- for i := len(matches) - 1; i >= 0; i-- {
- if processed >= types.MaxInlineDocumentImages {
- break
+ for _, match := range matches {
+ if _, ok := codeLiteralRangeAt(codeRanges, match.ImageStart); ok {
+ continue
}
- m := matches[i]
- if len(m) < 6 {
+ start, end := trimMarkdownSpaceBounds(markdown, match.TargetStart, match.TargetEnd)
+ if titleStart, ok := parseMarkdownImageTitleSuffix(markdown[start:end]); ok {
+ start, end = trimMarkdownSpaceBounds(markdown, start, start+titleStart)
+ }
+ if end-start >= 2 && markdown[start] == '<' && markdown[end-1] == '>' {
+ start++
+ end--
+ }
+ dataURI := markdown[start:end]
+ if !strings.HasPrefix(strings.ToLower(dataURI), "data:image/") || !containsBase64Marker(dataURI) {
+ continue
+ }
+ // A missing ')' can make the scanner consume the next paragraph.
+ // Let the bare resolver find a wrapped payload's actual boundary.
+ if strings.ContainsAny(dataURI, "\r\n") {
continue
}
- dataURI := markdown[m[4]:m[5]]
mimeType, payload, ok := parseImageDataURI(dataURI)
if !ok {
+ rewrites = append(rewrites, inlineRewrite{match.ImageStart, match.TargetEnd + 1, inlineImageOmitted})
continue
}
payload = cleanBase64Payload(payload)
if payload == "" {
+ rewrites = append(rewrites, inlineRewrite{match.ImageStart, match.TargetEnd + 1, inlineImageOmitted})
+ continue
+ }
+ if oversizedInlinePayload(payload) {
+ rewrites = append(rewrites, inlineRewrite{match.ImageStart, match.TargetEnd + 1, inlineImageOmitted})
continue
}
data, decErr := decodeBase64Flexible(payload)
if decErr != nil {
log.Printf("WARN: data URI base64 decode failed: %v", decErr)
+ rewrites = append(rewrites, inlineRewrite{match.ImageStart, match.TargetEnd + 1, inlineImageOmitted})
continue
}
if len(data) > maxRemoteImageSize {
log.Printf("WARN: data URI image exceeds size limit (%d bytes)", maxRemoteImageSize)
+ rewrites = append(rewrites, inlineRewrite{match.ImageStart, match.TargetEnd + 1, inlineImageOmitted})
+ continue
+ }
+ if !isCompleteInlineImage(data, mimeType) {
+ rewrites = append(rewrites, inlineRewrite{match.ImageStart, match.TargetEnd + 1, inlineImageOmitted})
continue
}
if isIconImage(data) {
- markdown = markdown[:m[0]] + markdown[m[1]:]
+ rewrites = append(rewrites, inlineRewrite{match.ImageStart, match.TargetEnd + 1, ""})
+ continue
+ }
+ if !quota.permits(len(data)) {
+ rewrites = append(rewrites, inlineRewrite{match.ImageStart, match.TargetEnd + 1, inlineImageOmitted})
continue
}
ext := extFromMime(mimeType)
@@ -754,18 +1660,18 @@ func (r *ImageResolver) ResolveDataURIImages(
fileName := uuid.New().String() + ext
servingURL, saveErr := fileSvc.SaveBytes(ctx, data, tenantID, fileName, false)
if saveErr != nil {
- log.Printf("WARN: failed to save data URI image: %v", saveErr)
- continue
+ return markdown, images, fmt.Errorf("save data URI image: %w", saveErr)
}
images = append(images, StoredImage{
OriginalRef: dataURI,
ServingURL: servingURL,
MimeType: mimeType,
+ Inline: true,
})
- markdown = markdown[:m[4]] + servingURL + markdown[m[5]:]
- processed++
+ rewrites = append(rewrites, inlineRewrite{start, end, servingURL})
}
- return markdown, images, nil
+ applyMultimodalBudget(images)
+ return applyInlineRewrites(markdown, rewrites), images, nil
}
// errRemoteImageIsIcon marks the one skip reason worth aggregating: a page can
diff --git a/internal/infrastructure/docparser/image_resolver_test.go b/internal/infrastructure/docparser/image_resolver_test.go
index 416e11f57..e856b110d 100644
--- a/internal/infrastructure/docparser/image_resolver_test.go
+++ b/internal/infrastructure/docparser/image_resolver_test.go
@@ -4,10 +4,14 @@ import (
"bytes"
"context"
"encoding/base64"
+ "encoding/binary"
"encoding/json"
+ "errors"
"fmt"
+ "hash/crc32"
"image"
"image/color"
+ "image/gif"
"image/png"
"io"
"mime/multipart"
@@ -207,6 +211,783 @@ func TestResolveHTMLDataURIImages(t *testing.T) {
}
}
+// assertLeadingImagesWinBudget verifies the inline resolver contract: images
+// come back in document order, every URL is substituted into the markdown,
+// and the leading maxInlineImagesForMultimodal join AI understanding while
+// the rest are stored but skipped.
+func assertLeadingImagesWinBudget(t *testing.T, out string, images []StoredImage) {
+ t.Helper()
+ prevPos := -1
+ for i, stored := range images {
+ pos := strings.Index(out, stored.ServingURL)
+ if pos < 0 {
+ t.Fatalf("stored URL %q missing from markdown", stored.ServingURL)
+ }
+ if pos <= prevPos {
+ t.Fatalf(
+ "stored URL %q is out of document order (pos %d after %d)",
+ stored.ServingURL, pos, prevPos,
+ )
+ }
+ prevPos = pos
+ if wantSkip := i >= maxInlineImagesForMultimodal; stored.SkipMultimodal != wantSkip {
+ t.Fatalf("image %d SkipMultimodal=%v, want %v", i, stored.SkipMultimodal, wantSkip)
+ }
+ }
+}
+
+func TestInlineImageStorageAppliesMultimodalBudgetInDocumentOrder(t *testing.T) {
+ b64 := base64.StdEncoding.EncodeToString(createTestPNG(200, 150))
+ image := `<img src="data:image/png;base64,` + b64 + `">`
+ for _, count := range []int{30, 31, 81} {
+ t.Run(fmt.Sprintf("%d images", count), func(t *testing.T) {
+ svc := &captureSaveBytes{}
+ out, images, err := NewImageResolver().ResolveHTMLDataURIImages(
+ context.Background(), strings.Repeat(image+"\n", count), svc, 1)
+ if err != nil {
+ t.Fatal(err)
+ }
+ if len(images) != count || len(svc.saved) != count {
+ t.Fatalf("images=%d saved=%d, want %d", len(images), len(svc.saved), count)
+ }
+ if HasUnresolvedInlineImagePayload(out) {
+ t.Fatal("inline image payload remained after storage")
+ }
+ if got := strings.Count(out, "local://test/"); got != count {
+ t.Fatalf("stored URL count=%d, want %d", got, count)
+ }
+ if len(uniqueStrings(imgServingURLs(images))) != count {
+ t.Fatalf(
+ "stored URLs are not unique: got %d, want %d",
+ len(uniqueStrings(imgServingURLs(images))), count,
+ )
+ }
+ for _, stored := range images {
+ if !stored.Inline {
+ t.Fatal("HTML data URI image was not marked inline")
+ }
+ }
+ assertLeadingImagesWinBudget(t, out, images)
+ })
+ }
+}
+
+func TestResolveAndStoreKeepsMarkdownAndHTMLImageBudgetsIndependent(t *testing.T) {
+ b64 := base64.StdEncoding.EncodeToString(createTestPNG(200, 150))
+ markdownImage := `![](data:image/png;base64,` + b64 + `)`
+ htmlImage := `<img src="data:image/png;base64,` + b64 + `">`
+ content := strings.Repeat(markdownImage+"\n", 31) + strings.Repeat(htmlImage+"\n", 31)
+ svc := &captureSaveBytes{}
+
+ updated, images, err := NewImageResolver().ResolveAndStore(
+ context.Background(),
+ &types.ReadResult{MarkdownContent: content},
+ svc,
+ 1,
+ )
+ if err != nil {
+ t.Fatalf("ResolveAndStore: %v", err)
+ }
+ if len(images) != 62 || len(svc.saved) != 62 {
+ t.Fatalf("images=%d saved=%d, want 62 each", len(images), len(svc.saved))
+ }
+ if HasUnresolvedInlineImagePayload(updated) {
+ t.Fatal("inline image payload remained after ResolveAndStore")
+ }
+ markdownEligible, htmlEligible := 0, 0
+ var markdownImages, htmlImages []StoredImage
+ for _, stored := range images {
+ if stored.OriginalRef == "html-img-data-uri" {
+ htmlImages = append(htmlImages, stored)
+ } else {
+ markdownImages = append(markdownImages, stored)
+ }
+ if stored.SkipMultimodal {
+ continue
+ }
+ if stored.OriginalRef == "html-img-data-uri" {
+ htmlEligible++
+ } else {
+ markdownEligible++
+ }
+ }
+ if markdownEligible != 30 || htmlEligible != 30 {
+ t.Fatalf("multimodal eligible: markdown=%d html=%d, want 30 each", markdownEligible, htmlEligible)
+ }
+ // Each syntax's images come back in document order and hand their own
+ // budget to their own leading images.
+ assertLeadingImagesWinBudget(t, updated, markdownImages)
+ assertLeadingImagesWinBudget(t, updated, htmlImages)
+}
+
+func TestResolveBareBase64ContentBudgetGoesToLeadingImages(t *testing.T) {
+ b64 := base64.StdEncoding.EncodeToString(createTestPNG(200, 150))
+ svc := &captureSaveBytes{}
+ out, images, err := NewImageResolver().ResolveBareBase64Content(
+ context.Background(), strings.Repeat("data:image/png;base64,"+b64+"\n", 81), svc, 1)
+ if err != nil {
+ t.Fatal(err)
+ }
+ if len(images) != 81 || len(svc.saved) != 81 {
+ t.Fatalf("images=%d saved=%d, want 81 each", len(images), len(svc.saved))
+ }
+ assertLeadingImagesWinBudget(t, out, images)
+}
+
+func TestResolveBareBase64PrefixBudgetGoesToLeadingImages(t *testing.T) {
+ b64 := base64.StdEncoding.EncodeToString(createTestPNG(200, 150))
+ svc := &captureSaveBytes{}
+ out, images, err := NewImageResolver().ResolveBareBase64Content(
+ context.Background(), strings.Repeat("base64,"+b64+"\n", 81), svc, 1)
+ if err != nil {
+ t.Fatal(err)
+ }
+ if len(images) != 81 || len(svc.saved) != 81 {
+ t.Fatalf("images=%d saved=%d, want 81 each", len(images), len(svc.saved))
+ }
+ assertLeadingImagesWinBudget(t, out, images)
+}
+
+type failAfterInlineSave struct {
+ captureSaveBytes
+ failAt int
+ calls int
+ deleted []string
+ deleteContextError error
+ deleteHasDeadline bool
+ cancelOnFailure context.CancelFunc
+}
+
+func (f *failAfterInlineSave) SaveBytes(
+ ctx context.Context, data []byte, tenantID uint64, fileName string, temp bool,
+) (string, error) {
+ f.calls++
+ if f.calls == f.failAt {
+ if f.cancelOnFailure != nil {
+ f.cancelOnFailure()
+ }
+ return "", errors.New("temporary storage failure")
+ }
+ return f.captureSaveBytes.SaveBytes(ctx, data, tenantID, fileName, temp)
+}
+
+func (f *failAfterInlineSave) DeleteFile(ctx context.Context, path string) error {
+ f.deleted = append(f.deleted, path)
+ f.deleteContextError = ctx.Err()
+ _, f.deleteHasDeadline = ctx.Deadline()
+ return nil
+}
+
+func TestResolveAndStoreRollsBackPartialInlineImageSaves(t *testing.T) {
+ b64 := base64.StdEncoding.EncodeToString(createTestPNG(200, 150))
+ image := `<img src="data:image/png;base64,` + b64 + `">`
+ ctx, cancel := context.WithCancel(context.Background())
+ defer cancel()
+ svc := &failAfterInlineSave{failAt: 3, cancelOnFailure: cancel}
+
+ _, images, err := NewImageResolver().ResolveAndStore(
+ ctx,
+ &types.ReadResult{MarkdownContent: strings.Repeat(image+"\n", 4)},
+ svc,
+ 1,
+ )
+
+ if err == nil || !strings.Contains(err.Error(), "temporary storage failure") {
+ t.Fatalf("err=%v, want temporary storage failure", err)
+ }
+ if len(images) != 2 || len(svc.saved) != 2 {
+ t.Fatalf("returned images=%d saved=%d, want two successful partial saves", len(images), len(svc.saved))
+ }
+ if len(svc.deleted) != 2 {
+ t.Fatalf("deleted=%v, want exactly the two objects saved during this attempt", svc.deleted)
+ }
+ if svc.deleteContextError != nil {
+ t.Errorf("rollback context error = %v, want nil after request cancellation", svc.deleteContextError)
+ }
+ if !svc.deleteHasDeadline {
+ t.Error("rollback context has no timeout deadline")
+ }
+ for _, savedURL := range svc.urls {
+ if !containsString(svc.deleted, savedURL) {
+ t.Errorf("newly saved object %q was not rolled back", savedURL)
+ }
+ }
+}
+
+func imgServingURLs(images []StoredImage) []string {
+ urls := make([]string, 0, len(images))
+ for _, img := range images {
+ urls = append(urls, img.ServingURL)
+ }
+ return urls
+}
+
+func uniqueStrings(values []string) []string {
+ seen := make(map[string]struct{}, len(values))
+ unique := make([]string, 0, len(values))
+ for _, value := range values {
+ if _, ok := seen[value]; ok {
+ continue
+ }
+ seen[value] = struct{}{}
+ unique = append(unique, value)
+ }
+ return unique
+}
+
+func containsString(values []string, target string) bool {
+ for _, value := range values {
+ if value == target {
+ return true
+ }
+ }
+ return false
+}
+
+type failingInlineImageSave struct{ captureSaveBytes }
+
+func (f *failingInlineImageSave) SaveBytes(context.Context, []byte, uint64, string, bool) (string, error) {
+ return "", errors.New("temporary storage failure")
+}
+
+func TestResolveHTMLDataURIImagesReturnsStorageFailure(t *testing.T) {
+ b64 := base64.StdEncoding.EncodeToString(createTestPNG(200, 150))
+ markdown := `<img src="data:image/png;base64,` + b64 + `">`
+ out, _, err := NewImageResolver().ResolveHTMLDataURIImages(
+ context.Background(), markdown, &failingInlineImageSave{}, 1)
+ if err == nil || !strings.Contains(err.Error(), "temporary storage failure") {
+ t.Fatalf("err=%v, want storage failure", err)
+ }
+ if !HasUnresolvedInlineImagePayload(out) {
+ t.Fatal("storage failure removed the payload before retry")
+ }
+}
+
+func TestHasUnresolvedInlineImagePayloadIgnoresOrdinaryBase64(t *testing.T) {
+ if HasUnresolvedInlineImagePayload("How does base64 work? Try base64,SGVsbG8= as an example.") {
+ t.Fatal("ordinary base64 text was treated as an image")
+ }
+}
+
+func TestHasUnresolvedInlineImagePayloadIgnoresFencedCodeExamples(t *testing.T) {
+ b64 := base64.StdEncoding.EncodeToString(createTestPNG(200, 150))
+ markdown := "```html\n<img src=\"data:image/png;base64," + b64 + "\">\n```"
+ if HasUnresolvedInlineImagePayload(markdown) {
+ t.Fatal("fenced code example was treated as an unresolved image")
+ }
+}
+
+func TestInlineImageCodeExamplesAreNeitherResolvedNorDetected(t *testing.T) {
+ b64 := base64.StdEncoding.EncodeToString(createTestPNG(200, 150))
+ for name, markdown := range map[string]string{
+ "single-backtick inline code": "Use `data:image/png;base64," + b64 + "` as an example.",
+ "multi-backtick inline code": "Use ``data:image/png;base64," + b64 + "`` as an example.",
+ "fenced code": "```text\ndata:image/png;base64," + b64 + "\n```",
+ } {
+ t.Run(name, func(t *testing.T) {
+ svc := &captureSaveBytes{}
+ out, images, err := NewImageResolver().ResolveBareBase64Content(
+ context.Background(), markdown, svc, 1)
+ if err != nil {
+ t.Fatal(err)
+ }
+ if len(images) != 0 || len(svc.saved) != 0 {
+ t.Fatalf("code example saved images=%d, saves=%d", len(images), len(svc.saved))
+ }
+ if out != markdown {
+ t.Fatalf("code example was rewritten: %q", out)
+ }
+ if HasUnresolvedInlineImagePayload(out) {
+ t.Fatal("code example was treated as an unresolved image")
+ }
+ })
+ }
+}
+
+func TestResolveAndStoreSkipsImageSyntaxInsideCodeExamples(t *testing.T) {
+ b64 := base64.StdEncoding.EncodeToString(createTestPNG(200, 150))
+ markdown := strings.Join([]string{
+ "`![](data:image/png;base64," + b64 + ")`",
+ "```html\n<img src=\"data:image/png;base64," + b64 + "\">\n```",
+ }, "\n\n")
+ svc := &captureSaveBytes{}
+ out, images, err := NewImageResolver().ResolveAndStore(
+ context.Background(), &types.ReadResult{MarkdownContent: markdown}, svc, 1)
+ if err != nil {
+ t.Fatal(err)
+ }
+ if len(images) != 0 || len(svc.saved) != 0 {
+ t.Fatalf("code examples saved images=%d, saves=%d", len(images), len(svc.saved))
+ }
+ if out != markdown {
+ t.Fatalf("code examples were rewritten: %q", out)
+ }
+ if HasUnresolvedInlineImagePayload(out) {
+ t.Fatal("code example was treated as an unresolved image")
+ }
+}
+
+func TestHasUnresolvedInlineImagePayloadIgnoresShortProseExample(t *testing.T) {
+ markdown := "Actual image: data:image/png;base64,not-valid-image-payload"
+ if HasUnresolvedInlineImagePayload(markdown) {
+ t.Fatal("ordinary prose must not fail document ingestion")
+ }
+}
+
+func TestHasUnresolvedInlineImagePayloadDetectsRealImageBytes(t *testing.T) {
+ payload := base64.StdEncoding.EncodeToString(createTestPNG(200, 150))
+ if !HasUnresolvedInlineImagePayload("data:image/png;base64," + payload) {
+ t.Fatal("unprocessed valid image bytes must be detected")
+ }
+}
+
+func TestSkippedMalformedImageSyntaxIsOmitted(t *testing.T) {
+ for _, markdown := range []string{
+ "![](data:image/png;base64,not-valid-payload)",
+ `<img src="data:image/png;base64,not-valid-payload">`,
+ } {
+ t.Run(markdown[:min(len(markdown), 20)], func(t *testing.T) {
+ out, images, err := NewImageResolver().ResolveAndStore(context.Background(),
+ &types.ReadResult{MarkdownContent: markdown}, &captureSaveBytes{}, 1)
+ if err != nil {
+ t.Fatal(err)
+ }
+ if len(images) != 0 {
+ t.Fatalf("stored %d malformed images", len(images))
+ }
+ if strings.Contains(out, "base64,") {
+ t.Fatalf("raw payload leaked: %q", out)
+ }
+ if !strings.Contains(out, "[image omitted]") {
+ t.Fatalf("missing placeholder: %q", out)
+ }
+ })
+ }
+}
+
+func TestOversizedInlineImagesAreOmitted(t *testing.T) {
+ data := make([]byte, maxRemoteImageSize+1)
+ copy(data, []byte("\x89PNG"))
+ payload := base64.StdEncoding.EncodeToString(data)
+
+ for _, input := range []string{
+ "![](data:image/png;base64," + payload + ")",
+ `<img src="data:image/png;base64,` + payload + `">`,
+ } {
+ out, images, err := NewImageResolver().ResolveAndStore(context.Background(),
+ &types.ReadResult{MarkdownContent: input}, &captureSaveBytes{}, 1)
+ if err != nil {
+ t.Fatal(err)
+ }
+ if len(images) != 0 {
+ t.Fatalf("oversized image unexpectedly saved: %d", len(images))
+ }
+ if out != inlineImageOmitted {
+ t.Fatalf("expected omitted image placeholder, got %q", out[:min(120, len(out))])
+ }
+ }
+}
+
+func TestWrappedBareDataURIIsResolvedWithoutLeakingPayload(t *testing.T) {
+ payload := base64.StdEncoding.EncodeToString(createTestPNG(200, 150))
+ var wrapped strings.Builder
+ for i := 0; i < len(payload); i += 76 {
+ if i > 0 {
+ wrapped.WriteByte('\n')
+ }
+ wrapped.WriteString(payload[i:min(i+76, len(payload))])
+ }
+ input := "Before\ndata:image/png;base64," + wrapped.String() + "\nAfter"
+ out, images, err := NewImageResolver().ResolveAndStore(context.Background(),
+ &types.ReadResult{MarkdownContent: input}, &captureSaveBytes{}, 1)
+ if err != nil {
+ t.Fatal(err)
+ }
+ if len(images) != 1 || !strings.Contains(out, images[0].ServingURL) {
+ t.Fatalf("valid wrapped Base64 should be stored; images=%d", len(images))
+ }
+ if strings.Contains(out, "base64,") || !strings.Contains(out, "Before") || !strings.Contains(out, "After") {
+ t.Fatal("wrapped data URI leaked or surrounding text was lost")
+ }
+}
+
+func TestBareDataURIKeepsFollowingEnglishParagraphs(t *testing.T) {
+ payload := base64.StdEncoding.EncodeToString(createTestPNG(200, 150))
+ input := "before data:image/png;base64," + payload +
+ "\nDocumentation\nAnotherParagraph\nAfter"
+
+ out, images, err := NewImageResolver().ResolveAndStore(context.Background(),
+ &types.ReadResult{MarkdownContent: input}, &captureSaveBytes{}, 1)
+ if err != nil {
+ t.Fatal(err)
+ }
+ if len(images) != 1 {
+ t.Fatalf("expected the valid PNG to be stored, got %d images", len(images))
+ }
+ for _, text := range []string{"before", "Documentation", "AnotherParagraph", "After", images[0].ServingURL} {
+ if !strings.Contains(out, text) {
+ t.Errorf("resolved document lost %q: %q", text, out)
+ }
+ }
+ if strings.Contains(out, inlineImageOmitted) || strings.Contains(out, "base64,") {
+ t.Fatalf("image should be replaced without dropping adjacent prose: %q", out)
+ }
+}
+
+func TestTruncatedWrappedImageReturnsErrorWithoutLosingProse(t *testing.T) {
+ payload := base64.StdEncoding.EncodeToString(createTestPNG(200, 150))
+ for _, prefix := range []string{"data:image/png;base64,", "base64,"} {
+ for _, length := range []int{76, 152} {
+ encoded := payload[:76]
+ if length > 76 {
+ encoded += "\n" + payload[76:length]
+ }
+ input := prefix + encoded + "\nDocumentation\nAnotherParagraph"
+ out, images, err := NewImageResolver().ResolveAndStore(context.Background(),
+ &types.ReadResult{MarkdownContent: input}, &captureSaveBytes{}, 1)
+ if !errors.Is(err, ErrAmbiguousInlineImage) || len(images) != 0 || out != input {
+ t.Fatalf("ambiguous image must return an error with original text: images=%d err=%v", len(images), err)
+ }
+ }
+ }
+}
+
+func TestMalformedMultilineInlineImagePreservesOriginal(t *testing.T) {
+ encoded := base64.StdEncoding.EncodeToString(createTestPNG(200, 150))
+ for _, prefix := range []string{"data:image/png;base64,", "base64,"} {
+ for _, firstLine := range []string{
+ encoded[:76], encoded[:76] + "\r", encoded[:76] + " \t", encoded[:64] + "!" + encoded[64:76],
+ } {
+ input := "[![](data:image/png;base64," + encoded + ")](https://example.com)\n\n" +
+ prefix + firstLine + "\n" + encoded[76:152] + "\n" + encoded[152:228] + "\n" + encoded[228:304] +
+ "\nPayment terms are net 30 days."
+ svc := &failAfterInlineSave{}
+ result := &types.ReadResult{MarkdownContent: input}
+ out, _, err := NewImageResolver().ResolveAndStore(context.Background(), result, svc, 1)
+ if !errors.Is(err, ErrAmbiguousInlineImage) {
+ t.Fatalf("expected explicit parse error, got %v", err)
+ }
+ if out != input || result.MarkdownContent != input {
+ t.Fatal("parse failure changed the original content")
+ }
+ if len(svc.saved) != 1 || len(svc.deleted) != 1 || svc.deleted[0] != svc.urls[0] {
+ t.Fatalf("partial upload was not rolled back: saved=%d deleted=%d", len(svc.saved), len(svc.deleted))
+ }
+ }
+ }
+}
+
+func TestTruncatedInlineImageBeforeProse(t *testing.T) {
+ encoded := base64.StdEncoding.EncodeToString(createTestPNG(200, 150))
+ for _, prefix := range []string{"data:image/png;base64,", "base64,"} {
+ for _, nextLine := range []string{
+ "这里是商品管理的重要业务说明。", "# Product management", encoded[76:152],
+ encoded[76:152] + " 这里是业务正文", encoded[76:120] + "!" + encoded[120:152],
+ "!" + encoded[76:152], "Documentation",
+ } {
+ input := prefix + encoded[:76] + "\n" + nextLine + "\n这是下一段正常正文。"
+ svc := &captureSaveBytes{}
+ out, images, err := NewImageResolver().ResolveAndStore(context.Background(),
+ &types.ReadResult{MarkdownContent: input}, svc, 1)
+ if strings.HasPrefix(nextLine, "这里") || strings.HasPrefix(nextLine, "#") {
+ if err != nil || out != inlineImageOmitted+"\n"+nextLine+"\n这是下一段正常正文。" ||
+ HasUnresolvedInlineImagePayload(out) {
+ t.Fatalf("clear prose must survive image omission: out=%q err=%v", out, err)
+ }
+ } else if !errors.Is(err, ErrAmbiguousInlineImage) || out != input {
+ t.Fatalf("possible encoding must stop ingestion with original text: err=%v", err)
+ }
+ if len(images) != 0 || len(svc.saved) != 0 {
+ t.Fatal("truncated image uploaded")
+ }
+ }
+ }
+}
+
+func TestUnknownInlineImageFormat(t *testing.T) {
+ for _, syntax := range []string{"bare", "markdown", "html"} {
+ for _, valid := range []bool{false, true} {
+ t.Run(fmt.Sprintf("%s/%t", syntax, valid), func(t *testing.T) {
+ data := bytes.Repeat([]byte{0, 1, 2, 3}, 256)
+ if valid {
+ data = createTestPNG(200, 150)
+ }
+ input := "data:image/fake;base64," + base64.StdEncoding.EncodeToString(data)
+ switch syntax {
+ case "markdown":
+ input = "![](" + input + ")"
+ case "html":
+ input = `<img src="` + input + `">`
+ }
+ svc := &captureSaveBytes{}
+ out, images, err := NewImageResolver().ResolveAndStore(context.Background(),
+ &types.ReadResult{MarkdownContent: input}, svc, 1)
+ if err != nil {
+ t.Fatal(err)
+ }
+ if valid {
+ if len(images) != 1 || len(svc.saved) != 1 || !bytes.Equal(svc.saved[0], data) {
+ t.Fatal("recognized valid image must remain supported")
+ }
+ } else if out != inlineImageOmitted || len(images) != 0 || len(svc.saved) != 0 {
+ t.Fatal("unrecognized binary content was accepted as an image")
+ }
+ })
+ }
+ }
+}
+
+func TestWrappedSVGIsStoredWithoutLeakingPayload(t *testing.T) {
+ svg := `<svg xmlns="http://www.w3.org/2000/svg" width="200" height="150"><!--` +
+ strings.Repeat("illustration ", 80) + `--><rect width="200" height="150"/></svg>`
+ for _, encoding := range []*base64.Encoding{base64.StdEncoding, base64.RawStdEncoding} {
+ payload := encoding.EncodeToString([]byte(svg))
+ var wrapped strings.Builder
+ for i := 0; i < len(payload); i += 76 {
+ if i > 0 {
+ wrapped.WriteByte('\n')
+ }
+ wrapped.WriteString(payload[i:min(i+76, len(payload))])
+ }
+ for _, prefix := range []string{"data:image/svg+xml;base64,", "base64,"} {
+ input := prefix + wrapped.String() + "\nDocumentation\nAnotherParagraph"
+ out, images, err := NewImageResolver().ResolveAndStore(context.Background(),
+ &types.ReadResult{MarkdownContent: input}, &captureSaveBytes{}, 1)
+ if err != nil {
+ t.Fatal(err)
+ }
+ if len(images) != 1 || images[0].MimeType != "image/svg+xml" {
+ t.Fatalf("wrapped SVG must be stored, got %v", images)
+ }
+ if out != "![image]("+images[0].ServingURL+")\nDocumentation\nAnotherParagraph" {
+ t.Fatalf("SVG payload leaked or prose changed: %q", out)
+ }
+ if !HasUnresolvedInlineImagePayload(input) {
+ t.Fatal("the guard must detect an unresolved SVG image")
+ }
+ }
+ }
+}
+
+func TestOversizedTruncatedWrappedImagePreservesOriginal(t *testing.T) {
+ payload := base64.StdEncoding.EncodeToString(createTestPNG(200, 150))[:76]
+ rows := maxRemoteImageSize/57 + 2 // Each full 76-character row decodes to 57 bytes.
+ input := "data:image/png;base64," + payload +
+ strings.Repeat("\n"+strings.Repeat("A", 76), rows) + "\nDocumentation"
+ out, images, err := NewImageResolver().ResolveAndStore(context.Background(),
+ &types.ReadResult{MarkdownContent: input}, &captureSaveBytes{}, 1)
+ if !errors.Is(err, ErrAmbiguousInlineImage) || len(images) != 0 || out != input {
+ t.Fatalf("oversized ambiguous image must preserve original text: images=%d err=%v", len(images), err)
+ }
+}
+
+func BenchmarkWrappedPayloadBeyondSizeLimit(b *testing.B) {
+ prefix := base64.StdEncoding.EncodeToString(createTestPNG(200, 150))[:76]
+ for _, decodedMiB := range []int{11, 22} {
+ input := prefix + strings.Repeat("\n"+strings.Repeat("A", 76), decodedMiB*1024*1024/57+1)
+ b.Run(fmt.Sprintf("%d_MiB", decodedMiB), func(b *testing.B) {
+ b.ReportAllocs()
+ b.SetBytes(int64(len(input)))
+ b.ResetTimer()
+ for i := 0; i < b.N; i++ {
+ end, complete, _ := wrappedBase64PayloadEnd(input, 0, 76)
+ if complete || end != 76 {
+ b.Fatal("oversized truncated payload must not consume uncertain continuation lines")
+ }
+ }
+ })
+ }
+}
+
+func TestInlineStorageLimitStillRetainsLeadingImageBudget(t *testing.T) {
+ payload := base64.StdEncoding.EncodeToString(createTestPNG(200, 150))
+ input := strings.Repeat(`<img src="data:image/png;base64,`+payload+`">`+"\n", maxInlineImagesPerDocument+1)
+ svc := &captureSaveBytes{}
+ out, images, err := NewImageResolver().ResolveAndStore(context.Background(),
+ &types.ReadResult{MarkdownContent: input}, svc, 1)
+ if err != nil {
+ t.Fatal(err)
+ }
+ if len(images) != maxInlineImagesPerDocument || len(svc.saved) != maxInlineImagesPerDocument {
+ t.Fatalf("stored=%d saved=%d, want %d", len(images), len(svc.saved), maxInlineImagesPerDocument)
+ }
+ if strings.Count(out, inlineImageOmitted) != 1 {
+ t.Fatalf("expected one omitted image; got %d", strings.Count(out, inlineImageOmitted))
+ }
+ assertLeadingImagesWinBudget(t, out, images)
+}
+
+func TestBareInlineSyntaxesKeepSeparateAIBudgets(t *testing.T) {
+ payload := base64.StdEncoding.EncodeToString(createTestPNG(200, 150))
+ input := strings.Repeat("data:image/png;base64,"+payload+"\n", 31) +
+ strings.Repeat("base64,"+payload+"\n", 31)
+ svc := &captureSaveBytes{}
+ out, images, err := NewImageResolver().ResolveBareBase64Content(context.Background(), input, svc, 1)
+ if err != nil {
+ t.Fatal(err)
+ }
+ if len(images) != 62 || len(svc.saved) != 62 {
+ t.Fatalf("stored=%d saved=%d, want 62", len(images), len(svc.saved))
+ }
+ var dataURI, prefix []StoredImage
+ for _, img := range images {
+ switch img.OriginalRef {
+ case "bare-data-uri":
+ dataURI = append(dataURI, img)
+ case "bare-base64":
+ prefix = append(prefix, img)
+ default:
+ t.Fatalf("unexpected image source %q", img.OriginalRef)
+ }
+ }
+ if len(dataURI) != 31 || len(prefix) != 31 {
+ t.Fatalf("bare syntax counts=%d/%d, want 31 each", len(dataURI), len(prefix))
+ }
+ assertLeadingImagesWinBudget(t, out, dataURI)
+ assertLeadingImagesWinBudget(t, out, prefix)
+}
+
+func TestShortWrappedBareImageDoesNotLeakRemainder(t *testing.T) {
+ payload := base64.StdEncoding.EncodeToString(createTestPNG(200, 150))
+ var wrapped strings.Builder
+ for i := 0; i < len(payload); i += wrappedBase64LineLength {
+ if i > 0 {
+ wrapped.WriteByte('\n')
+ }
+ wrapped.WriteString(payload[i:min(i+wrappedBase64LineLength, len(payload))])
+ }
+ input := "Before\ndata:image/png;base64," + wrapped.String() + "\nAfter"
+ out, _, err := NewImageResolver().ResolveBareBase64Content(context.Background(),
+ input, &captureSaveBytes{}, 1)
+ if err != nil {
+ t.Fatal(err)
+ }
+ if strings.Contains(out, "base64,") || strings.Contains(out, payload[wrappedBase64LineLength:]) {
+ t.Fatalf("short wrapped image leaked into body: %q", out)
+ }
+ if !strings.Contains(out, "Before") || !strings.Contains(out, "After") {
+ t.Fatalf("surrounding text was dropped: %q", out)
+ }
+}
+
+func TestMalformedBareImageIsRemovedAsOneToken(t *testing.T) {
+ payload := base64.StdEncoding.EncodeToString(createTestPNG(200, 150))
+ broken := payload[:128] + "!" + payload[128:] + strings.Repeat("A", 4096)
+ input := "before data:image/png;base64," + broken + " after"
+ out, images, err := NewImageResolver().ResolveBareBase64Content(context.Background(),
+ input, &captureSaveBytes{}, 1)
+ if err != nil {
+ t.Fatal(err)
+ }
+ if len(images) != 0 {
+ t.Fatalf("malformed data unexpectedly saved: %d", len(images))
+ }
+ if !strings.Contains(out, inlineImageOmitted) || strings.Contains(out, "base64,") ||
+ strings.Contains(out, strings.Repeat("A", 128)) {
+ t.Fatalf("malformed encoded tail leaked: %q", out[:min(200, len(out))])
+ }
+}
+
+func TestHTMLAndIndentedCodeExamplesArePreserved(t *testing.T) {
+ payload := base64.StdEncoding.EncodeToString(createTestPNG(200, 150))
+ token := "data:image/png;base64," + payload
+ content := " " + token + "\n<pre><code>" + token + "</code></pre>\n" +
+ "<code>" + token + "</code>\n![](" + token + ")"
+ svc := &captureSaveBytes{}
+ out, images, err := NewImageResolver().ResolveAndStore(context.Background(),
+ &types.ReadResult{MarkdownContent: content}, svc, 1)
+ if err != nil {
+ t.Fatal(err)
+ }
+ if len(images) != 1 {
+ t.Fatalf("literal examples must not be uploaded, got %d images", len(images))
+ }
+ if strings.Count(out, token) != 3 {
+ t.Fatalf("literal code image examples changed: %q", out[:min(200, len(out))])
+ }
+ if HasUnresolvedInlineImagePayload(out) {
+ t.Fatal("literal HTML or indented code triggered unresolved-image guard")
+ }
+}
+
+func TestIndentedListItemImageIsNotMistakenForCode(t *testing.T) {
+ payload := base64.StdEncoding.EncodeToString(createTestPNG(200, 150))
+ input := "- Product example\n ![](data:image/png;base64," + payload + ")"
+ out, images, err := NewImageResolver().ResolveAndStore(context.Background(),
+ &types.ReadResult{MarkdownContent: input}, &captureSaveBytes{}, 1)
+ if err != nil {
+ t.Fatal(err)
+ }
+ if len(images) != 1 {
+ t.Fatalf("list image must be stored, found %d stored images", len(images))
+ }
+ if strings.Contains(out, "base64,") || !strings.Contains(out, images[0].ServingURL) {
+ t.Fatalf("list image was not resolved: %q", out)
+ }
+}
+
+func TestTabIndentedCodeExampleIsPreserved(t *testing.T) {
+ payload := base64.StdEncoding.EncodeToString(createTestPNG(200, 150))
+ input := "\tdata:image/png;base64," + payload
+ out, images, err := NewImageResolver().ResolveAndStore(context.Background(),
+ &types.ReadResult{MarkdownContent: input}, &captureSaveBytes{}, 1)
+ if err != nil {
+ t.Fatal(err)
+ }
+ if len(images) != 0 || out != input {
+ t.Fatalf("tab-indented code example changed: images=%d output=%q", len(images), out)
+ }
+ if HasUnresolvedInlineImagePayload(out) {
+ t.Fatal("tab-indented code example triggered unresolved-image guard")
+ }
+}
+
+func TestIndentedCodeInsideListIsNotResolved(t *testing.T) {
+ payload := base64.StdEncoding.EncodeToString(createTestPNG(200, 150))
+ input := "- Product example\n\n ![](data:image/png;base64," + payload + ")"
+ out, images, err := NewImageResolver().ResolveAndStore(context.Background(),
+ &types.ReadResult{MarkdownContent: input}, &captureSaveBytes{}, 1)
+ if err != nil {
+ t.Fatal(err)
+ }
+ if len(images) != 0 {
+ t.Fatalf("indented list code example was uploaded, got %d", len(images))
+ }
+ if out != input || HasUnresolvedInlineImagePayload(out) {
+ t.Fatal("indented list code example must stay literal and not trigger guard")
+ }
+}
+
+func BenchmarkHasUnresolvedInlineImagePayloadWithManyFencedCodeBlocks(b *testing.B) {
+ const codeBlock = "```text\ndata:image/png;base64," +
+ "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" +
+ "\n```\n"
+ markdown := strings.Repeat(codeBlock, 1000)
+ b.SetBytes(int64(len(markdown)))
+ b.ResetTimer()
+ for i := 0; i < b.N; i++ {
+ if HasUnresolvedInlineImagePayload(markdown) {
+ b.Fatal("code examples must not be treated as unresolved image payloads")
+ }
+ }
+}
+
+func BenchmarkHasUnresolvedInlineImagePayloadWithManyIndentedCodeLines(b *testing.B) {
+ payload := base64.StdEncoding.EncodeToString(createTestPNG(200, 150))
+ for _, lineCount := range []int{1000, 3000, 6000} {
+ markdown := strings.Repeat(" data:image/png;base64,"+payload+"\n", lineCount)
+ b.Run(fmt.Sprintf("%d_lines", lineCount), func(b *testing.B) {
+ b.SetBytes(int64(len(markdown)))
+ b.ResetTimer()
+ for i := 0; i < b.N; i++ {
+ if HasUnresolvedInlineImagePayload(markdown) {
+ b.Fatal("indented code examples must not be treated as unresolved images")
+ }
+ }
+ })
+ }
+}
+
func TestResolveBareBase64Content_BareDataURI(t *testing.T) {
png := createTestPNG(200, 150)
b64 := base64.StdEncoding.EncodeToString(png)
@@ -636,6 +1417,472 @@ func TestResolveAndStoreSharedMHTMLContract(t *testing.T) {
}
}
+// Exercise the ingestion boundary, including the guard used before chunking.
+func TestInlineImageIntegrityAndProse(t *testing.T) {
+ originalPNG := createTestPNG(200, 150)
+ svg := []byte(`<svg xmlns="http://www.w3.org/2000/svg"><!--` + strings.Repeat("drawing ", 90) + `--><rect/></svg>`)
+ prefacedSVG := append([]byte(`<?xml version="1.0"?><!--`+strings.Repeat("preface ", 90)+`-->`), svg...)
+ prose := "\nDocumentation\nAnotherParagraph\nThis business rule is essential.\n" +
+ "Payment terms are net 30 (days).\n中文正文\n" + strings.Repeat("BusinessIdentifier", 8)
+ cases := []struct {
+ name string
+ data []byte
+ valid bool
+ }{
+ {"png", originalPNG, true},
+ {"png-first-line", originalPNG[:48], false},
+ // Even a padded truncated tail cannot establish the boundary of subsequent prose.
+ {"png-second-line", originalPNG[:95], false},
+ {"png-near-end", originalPNG[:len(originalPNG)-12], false},
+ {"svg", svg, true},
+ {"svg-preface", prefacedSVG, true},
+ {"svg-truncated", prefacedSVG[:len(prefacedSVG)-6], false},
+ }
+ for _, tc := range cases {
+ for _, width := range []int{0, 64, 76, 80, 120} {
+ mime := "png"
+ if strings.HasPrefix(tc.name, "svg") {
+ mime = "svg+xml"
+ }
+ for _, prefix := range []string{"data:image/" + mime + ";base64,", "base64,"} {
+ t.Run(fmt.Sprintf("%s/%d/%s", tc.name, width, prefix), func(t *testing.T) {
+ encoded := base64.StdEncoding.EncodeToString(tc.data)
+ var lines []string
+ if width == 0 {
+ lines = []string{encoded}
+ } else {
+ for i := 0; i < len(encoded); i += width {
+ lines = append(lines, encoded[i:min(i+width, len(encoded))])
+ }
+ }
+ svc := &captureSaveBytes{}
+ input := prefix + strings.Join(lines, "\n") + prose
+ out, images, err := NewImageResolver().ResolveAndStore(context.Background(),
+ &types.ReadResult{MarkdownContent: input}, svc, 1)
+ if !tc.valid {
+ // An XML preamble without a visible SVG root cannot identify
+ // a bare Base64 fragment as an image; leave it wholly untouched.
+ unknownImage := tc.name == "svg-truncated" && prefix == "base64," && width > 0
+ if (unknownImage && err != nil) || (!unknownImage && !errors.Is(err, ErrAmbiguousInlineImage)) {
+ t.Fatalf("unexpected parse result: %v", err)
+ }
+ if out != input || len(images) != 0 || len(svc.saved) != 0 {
+ t.Fatal("ambiguous image was modified or uploaded")
+ }
+ return
+ }
+ if err != nil {
+ t.Fatal(err)
+ }
+ if len(images) != 1 || len(svc.saved) != 1 {
+ t.Fatalf("images=%d saves=%d", len(images), len(svc.saved))
+ }
+ if !bytes.Equal(svc.saved[0], tc.data) {
+ t.Fatal("stored bytes differ from original")
+ }
+ replacement := "![image](" + images[0].ServingURL + ")"
+ if out != replacement+prose {
+ t.Fatalf("unexpected payload boundary or prose changed: %q", out)
+ }
+ if HasUnresolvedInlineImagePayload(out) {
+ t.Fatal("resolved content must not trigger the guard")
+ }
+ })
+ }
+ }
+ }
+}
+
+func TestBrokenMarkdownImagePreservesBusinessProse(t *testing.T) {
+ payload := base64.StdEncoding.EncodeToString(createTestPNG(200, 150))
+ for _, length := range []int{0, 64, len(payload)} {
+ t.Run(fmt.Sprint(length), func(t *testing.T) {
+ prose := "\nThis business rule is essential.\n\nPayment terms are net 30 (days)."
+ svc := &captureSaveBytes{}
+ input := "![](data:image/png;base64," + payload[:length] + prose
+ out, _, err := NewImageResolver().ResolveAndStore(context.Background(),
+ &types.ReadResult{MarkdownContent: input}, svc, 1)
+ if length == 64 {
+ if !errors.Is(err, ErrAmbiguousInlineImage) || out != input || len(svc.saved) != 0 {
+ t.Fatalf("ambiguous image must fail without changing prose: %v", err)
+ }
+ return
+ }
+ if err != nil {
+ t.Fatal(err)
+ }
+ if !strings.HasSuffix(out, prose) {
+ t.Fatalf("business prose changed: %q", out)
+ }
+ if HasUnresolvedInlineImagePayload(out) {
+ t.Fatal("guard rejected degraded image")
+ }
+ })
+ }
+}
+
+func TestInlineImageRejectsInvalidStructure(t *testing.T) {
+ corruptPNG := append([]byte(nil), createTestPNG(200, 150)...)
+ // Keep the header and IEND intact while invalidating the IDAT checksum.
+ corruptPNG[len(corruptPNG)-13] ^= 1
+ corruptBMP := make([]byte, 1024)
+ copy(corruptBMP, "BM")
+ binary.LittleEndian.PutUint32(corruptBMP[2:6], uint32(len(corruptBMP)))
+ corruptWebP := make([]byte, 1024)
+ copy(corruptWebP, "RIFF")
+ copy(corruptWebP[8:], "WEBP")
+ binary.LittleEndian.PutUint32(corruptWebP[4:8], uint32(len(corruptWebP)-8))
+ cases := []struct {
+ name, mime string
+ data []byte
+ }{
+ {"png-checksum", "png", corruptPNG},
+ {"bmp-header-only", "bmp", corruptBMP},
+ {"webp-header-only", "webp", corruptWebP},
+ {"svg-mismatched", "svg+xml", []byte(`<svg><!--` + strings.Repeat("drawing ", 90) + `--><g></svg>`)},
+ {
+ "svg-wrong-root", "svg+xml",
+ []byte(`<document><!--` + strings.Repeat("drawing ", 90) + `--><svg/></document>`),
+ },
+ {"svg-multiple-roots", "svg+xml", []byte(`<svg><!--` + strings.Repeat("drawing ", 90) + `--></svg><svg/>`)},
+ }
+ for _, tc := range cases {
+ for _, syntax := range []string{"bare", "markdown", "html"} {
+ t.Run(tc.name+"/"+syntax, func(t *testing.T) {
+ source := "data:image/" + tc.mime + ";base64," + base64.StdEncoding.EncodeToString(tc.data)
+ if syntax == "markdown" {
+ source = "![](" + source + ")"
+ }
+ if syntax == "html" {
+ source = `<img src="` + source + `">`
+ }
+ svc := &captureSaveBytes{}
+ out, images, err := NewImageResolver().ResolveAndStore(context.Background(),
+ &types.ReadResult{MarkdownContent: source}, svc, 1)
+ if err != nil {
+ t.Fatal(err)
+ }
+ if out != inlineImageOmitted || len(images) != 0 || len(svc.saved) != 0 {
+ t.Fatalf("invalid image was not safely omitted: %q, images=%d saves=%d",
+ out, len(images), len(svc.saved))
+ }
+ })
+ }
+ }
+}
+
+func TestBareBase64XMLTextIsPreserved(t *testing.T) {
+ for _, text := range []string{
+ `<?xml version="1.0"?><document><!--` + strings.Repeat("notes ", 100) + `--></document>`,
+ `<!--` + strings.Repeat("notes ", 100) + `--><document><svg/></document>`,
+ } {
+ input := "base64," + base64.StdEncoding.EncodeToString([]byte(text))
+ svc := &captureSaveBytes{}
+ out, images, err := NewImageResolver().ResolveAndStore(context.Background(),
+ &types.ReadResult{MarkdownContent: input}, svc, 1)
+ if err != nil {
+ t.Fatal(err)
+ }
+ if out != input || len(images) != 0 || len(svc.saved) != 0 ||
+ HasUnresolvedInlineImagePayload(out) {
+ t.Fatal("ordinary XML was treated as an image")
+ }
+ }
+}
+
+func TestTruncatedImagePreservesAmbiguousFullWidthProse(t *testing.T) {
+ payload := base64.StdEncoding.EncodeToString(createTestPNG(200, 150))
+ for _, width := range []int{64, 76, 80, 120} {
+ for _, prefix := range []string{"data:image/png;base64,", "base64,"} {
+ t.Run(fmt.Sprintf("%d/%s", width, prefix), func(t *testing.T) {
+ prose := "\n" + strings.Repeat("Business", width/8) + strings.Repeat("X", width%8) +
+ "\nDocumentation\nAnotherParagraph"
+ svc := &captureSaveBytes{}
+ input := prefix + payload[:width] + prose
+ out, _, err := NewImageResolver().ResolveAndStore(context.Background(),
+ &types.ReadResult{MarkdownContent: input}, svc, 1)
+ if !errors.Is(err, ErrAmbiguousInlineImage) || out != input || len(svc.saved) != 0 {
+ t.Fatalf("ambiguous prose must be preserved with a parse error: %v", err)
+ }
+ })
+ }
+ }
+}
+
+func TestWrappedSelfClosingSVG(t *testing.T) {
+ for _, width := range []int{64, 76} {
+ // End a self-closing SVG on a full Base64 line, without padding.
+ size := width * 9
+ opening, closing := `<svg xmlns="http://www.w3.org/2000/svg" data-note="`, `"/>`
+ svg := []byte(opening + strings.Repeat("a", size-len(opening)-len(closing)) + closing)
+ encoded := base64.StdEncoding.EncodeToString(svg)
+ var lines []string
+ for i := 0; i < len(encoded); i += width {
+ lines = append(lines, encoded[i:i+width])
+ }
+ svc := &captureSaveBytes{}
+ out, images, err := NewImageResolver().ResolveAndStore(context.Background(),
+ &types.ReadResult{MarkdownContent: "base64," + strings.Join(lines, "\n") + "\nDocumentation"}, svc, 1)
+ if err != nil {
+ t.Fatal(err)
+ }
+ if len(images) != 1 || len(svc.saved) != 1 || !bytes.Equal(svc.saved[0], svg) {
+ t.Fatalf("%d-column SVG was not stored intact", width)
+ }
+ if out != "![image]("+images[0].ServingURL+")\nDocumentation" {
+ t.Fatal("SVG boundary was lost")
+ }
+ }
+}
+
+func TestBareImageTrailingPunctuation(t *testing.T) {
+ original := createTestPNG(200, 150)
+ payload := base64.StdEncoding.EncodeToString(original)
+ damaged := payload[:128] + "!" + payload[128:] + strings.Repeat("A", 4096)
+ prose := "\nDocumentation\nAnotherParagraph\nPayment terms are net 30 (days).\n中文正文"
+ for _, prefix := range []string{"data:image/png;base64,", "base64,"} {
+ for _, punctuation := range []string{".", ",", ";", ""} {
+ for _, broken := range []bool{false, true} {
+ t.Run(fmt.Sprintf("%s/%s/%t", prefix, punctuation, broken), func(t *testing.T) {
+ encoded := payload
+ if broken {
+ encoded = damaged
+ }
+ svc := &captureSaveBytes{}
+ input := prefix + encoded + punctuation + prose
+ out, images, err := NewImageResolver().ResolveAndStore(context.Background(),
+ &types.ReadResult{MarkdownContent: input}, svc, 1)
+ if broken && punctuation == "" {
+ if !errors.Is(err, ErrAmbiguousInlineImage) || out != input ||
+ len(svc.saved) != 0 || len(images) != 0 {
+ t.Fatalf("unbounded damaged image must preserve original text: %v", err)
+ }
+ return
+ }
+ if err != nil {
+ t.Fatal(err)
+ }
+ replacement := inlineImageOmitted
+ if broken {
+ if len(svc.saved) != 0 || len(images) != 0 {
+ t.Fatal("damaged image uploaded")
+ }
+ } else {
+ if len(svc.saved) != 1 || len(images) != 1 || !bytes.Equal(svc.saved[0], original) {
+ t.Fatal("image was not saved byte-for-byte")
+ }
+ replacement = "![image](" + images[0].ServingURL + ")"
+ }
+ if out != replacement+punctuation+prose {
+ t.Fatalf("encoding residue or prose changed: %q", out)
+ }
+ if HasUnresolvedInlineImagePayload(out) {
+ t.Fatal("resolved image triggered guard")
+ }
+ })
+ }
+ }
+ }
+}
+
+func TestInlineImageDecodeResourceLimits(t *testing.T) {
+ var largePNG bytes.Buffer
+ // A valid, compact 24 MP PNG is outside the fixed inline decoding support limit.
+ if err := png.Encode(&largePNG, image.NewGray(image.Rect(0, 0, 6000, 4000))); err != nil {
+ t.Fatal(err)
+ }
+ frame := image.NewPaletted(image.Rect(0, 0, 512, 512), color.Palette{color.Black, color.White})
+ var animation bytes.Buffer
+ frames := make([]*image.Paletted, 140)
+ for i := range frames {
+ frames[i] = frame
+ }
+ if err := gif.EncodeAll(&animation, &gif.GIF{Image: frames, Delay: make([]int, len(frames))}); err != nil {
+ t.Fatal(err)
+ }
+ brokenAnimation := append([]byte(nil), animation.Bytes()[:animation.Len()-2]...)
+ brokenAnimation = append(brokenAnimation, ';') // Missing the final sub-block terminator.
+ var smallAnimation, tooManyFrames bytes.Buffer
+ if err := gif.EncodeAll(&smallAnimation, &gif.GIF{Image: frames[:2], Delay: make([]int, 2)}); err != nil {
+ t.Fatal(err)
+ }
+ tinyFrame := image.NewPaletted(image.Rect(0, 0, 64, 64), color.Palette{color.Black, color.White})
+ tinyFrames := make([]*image.Paletted, 257)
+ for i := range tinyFrames {
+ tinyFrames[i] = tinyFrame
+ }
+ if err := gif.EncodeAll(&tooManyFrames, &gif.GIF{
+ Image: tinyFrames, Delay: make([]int, len(tinyFrames)),
+ }); err != nil {
+ t.Fatal(err)
+ }
+ for _, tc := range []struct {
+ name, mime string
+ data []byte
+ supported bool
+ }{
+ {"pixel-budget", "png", largePNG.Bytes(), false},
+ {"broken-pixel-budget", "png", largePNG.Bytes()[:largePNG.Len()-12], false},
+ {"animation-budget", "gif", animation.Bytes(), false},
+ {"frame-budget", "gif", tooManyFrames.Bytes(), false},
+ {"valid-animation", "gif", smallAnimation.Bytes(), true},
+ {"broken-animation", "gif", brokenAnimation, false},
+ } {
+ for _, syntax := range []string{
+ "bare", "bare-base64", "bare-wrapped", "bare-base64-wrapped", "markdown", "html",
+ } {
+ t.Run(tc.name+"/"+syntax, func(t *testing.T) {
+ encoded := base64.StdEncoding.EncodeToString(tc.data)
+ if strings.HasSuffix(syntax, "wrapped") {
+ var lines []string
+ for i := 0; i < len(encoded); i += 76 {
+ lines = append(lines, encoded[i:min(i+76, len(encoded))])
+ }
+ encoded = strings.Join(lines, "\n")
+ }
+ source := "data:image/" + tc.mime + ";base64," + encoded
+ if strings.HasPrefix(syntax, "bare-base64") {
+ source = "base64," + encoded
+ }
+ if syntax == "markdown" {
+ source = "![](" + source + ")"
+ }
+ if syntax == "html" {
+ source = `<img src="` + source + `">`
+ }
+ prose := "\nDocumentation\nAnotherParagraph"
+ svc := &captureSaveBytes{}
+ out, images, err := NewImageResolver().ResolveAndStore(context.Background(),
+ &types.ReadResult{MarkdownContent: source + prose}, svc, 1)
+ if strings.HasPrefix(tc.name, "broken-") && strings.HasPrefix(syntax, "bare") {
+ if !errors.Is(err, ErrAmbiguousInlineImage) || out != source+prose || len(svc.saved) != 0 {
+ t.Fatal("a decode limit must not excuse an incomplete image boundary")
+ }
+ return
+ }
+ if err != nil {
+ t.Fatal(err)
+ }
+ replacement := inlineImageOmitted
+ if tc.supported {
+ if len(images) != 1 || len(svc.saved) != 1 || !bytes.Equal(svc.saved[0], tc.data) {
+ t.Fatal("image within the validation budget was not preserved")
+ }
+ replacement = "![image](" + images[0].ServingURL + ")"
+ if syntax == "markdown" {
+ replacement = "![](" + images[0].ServingURL + ")"
+ }
+ } else if len(images) != 0 || len(svc.saved) != 0 {
+ t.Fatal("invalid or unverifiable image was stored")
+ }
+ if out != replacement+prose {
+ t.Fatal("resource filtering left payload or changed prose")
+ }
+ if HasUnresolvedInlineImagePayload(out) {
+ t.Fatal("omitted image triggered guard")
+ }
+ })
+ }
+ }
+}
+
+func TestWrappedImageFragmentBoundaries(t *testing.T) {
+ original := createTestPNG(200, 150)
+ encoded := base64.StdEncoding.EncodeToString(original)
+ for _, width := range []int{80, 120} {
+ for _, newline := range []string{"\n", "\r\n"} {
+ for _, prefix := range []string{"data:image/png;base64,", "base64,"} {
+ t.Run(fmt.Sprintf("%d/%q/%s", width, newline, prefix), func(t *testing.T) {
+ var lines []string
+ for i := 0; i < len(encoded); i += width {
+ lines = append(lines, encoded[i:min(i+width, len(encoded))])
+ }
+ prose := ". Payment terms are net 30 (days)." + newline + "Documentation" + newline + "中文正文"
+ svc := &captureSaveBytes{}
+ out, images, err := NewImageResolver().ResolveAndStore(context.Background(),
+ &types.ReadResult{MarkdownContent: prefix + strings.Join(lines, newline) + prose}, svc, 1)
+ if err != nil {
+ t.Fatal(err)
+ }
+ if len(images) != 1 || len(svc.saved) != 1 || !bytes.Equal(svc.saved[0], original) {
+ t.Fatal("wrapped image changed")
+ }
+ if out != "![image]("+images[0].ServingURL+")"+prose {
+ t.Fatalf("encoding residue or prose changed: %q", out)
+ }
+ if HasUnresolvedInlineImagePayload(out) {
+ t.Fatal("resolved wrapped image triggered guard")
+ }
+ })
+ }
+ }
+ }
+}
+
+func TestTruncatedWrappedSVGPreservesAlphabeticProse(t *testing.T) {
+ svg := `<svg xmlns="http://www.w3.org/2000/svg"><!--` + strings.Repeat("drawing ", 90) + `--></svg>`
+ payload := base64.StdEncoding.EncodeToString([]byte(svg))[:76]
+ prose := "\nAABB\nDocumentation\nAnotherParagraph"
+ for _, prefix := range []string{"data:image/svg+xml;base64,", "base64,"} {
+ svc := &captureSaveBytes{}
+ input := prefix + payload + prose
+ out, images, err := NewImageResolver().ResolveAndStore(context.Background(),
+ &types.ReadResult{MarkdownContent: input}, svc, 1)
+ if !errors.Is(err, ErrAmbiguousInlineImage) || out != input || len(images) != 0 || len(svc.saved) != 0 {
+ t.Fatalf("ambiguous SVG must preserve original text: %v", err)
+ }
+ }
+}
+
+func TestDamagedInlineImageBoundaries(t *testing.T) {
+ truncated := base64.StdEncoding.EncodeToString(createTestPNG(200, 150)[:48])
+ for _, suffix := range []string{"\nINV202600001\n正文", "\norder/item-2026\n正文", "\nAAAA\n正文", "\nTOTAL=100\n正文"} {
+ for _, prefix := range []string{"data:image/png;base64,", "base64,"} {
+ input := prefix + truncated + suffix
+ out, images, err := NewImageResolver().ResolveAndStore(context.Background(),
+ &types.ReadResult{MarkdownContent: input}, &captureSaveBytes{}, 1)
+ if !errors.Is(err, ErrAmbiguousInlineImage) || len(images) != 0 || out != input {
+ t.Fatalf("damaged image consumed prose: out=%q images=%d err=%v", out, len(images), err)
+ }
+ }
+ }
+ for _, quote := range []string{"\"", "'"} {
+ input := "<img src=" + quote + "data:image/png;base64," + truncated + ">\n正文"
+ out, images, err := NewImageResolver().ResolveAndStore(context.Background(),
+ &types.ReadResult{MarkdownContent: input}, &captureSaveBytes{}, 1)
+ if err != nil || len(images) != 0 || out != "<img src="+quote+inlineImageOmitted+">\n正文" ||
+ HasUnresolvedInlineImagePayload(out) {
+ t.Fatalf("unclosed image not omitted locally: out=%q images=%d err=%v", out, len(images), err)
+ }
+ }
+}
+
+func TestInlinePNGWithoutPixelDataIsOmitted(t *testing.T) {
+ original := createTestPNG(200, 150)
+ for _, width := range []uint32{200, 4097} {
+ data := append([]byte(nil), original[:33]...)
+ binary.BigEndian.PutUint32(data[16:20], width)
+ binary.BigEndian.PutUint32(data[20:24], 4097)
+ binary.BigEndian.PutUint32(data[29:33], crc32.ChecksumIEEE(data[12:29]))
+ data = append(data, original[len(original)-12:]...) // No IDAT: deliberately no pixel data.
+ input := "![](data:image/png;base64," + base64.StdEncoding.EncodeToString(data) + ")\n正文"
+ svc := &captureSaveBytes{}
+ out, images, err := NewImageResolver().ResolveAndStore(context.Background(),
+ &types.ReadResult{MarkdownContent: input}, svc, 1)
+ if err != nil ||
+ HasUnresolvedInlineImagePayload(out) {
+ t.Fatalf("unexpected failure: %v", err)
+ }
+ want := inlineImageOmitted + "\n正文"
+ if len(images) != 0 || len(svc.saved) != 0 {
+ t.Fatalf("PNG without pixel data was stored at width %d", width)
+ }
+ if out != want {
+ t.Fatalf("out=%q want=%q", out, want)
+ }
+ }
+}
+
func TestResolveAndStore_ExportImageRefsBeyondInlineBudget(t *testing.T) {
data := createTestPNG(200, 150)
result := &types.ReadResult{}