Open-source LLM knowledge platform: turn raw documents into a queryable RAG, an autonomous reasoning agent, and a self-maintaining Wiki.
Go agentagenticaichatbotdsh-pluginembeddingsevaluationgenerative-aigolangknowledge-basellmmulti-tenantollamaopenaiquestion-answeringragrerankingsemantic-searchvector-searchwiki
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.goindex 413dce685..33adbfc71 100644--- a/internal/application/service/knowledge_create.go+++ b/internal/application/service/knowledge_create.go@@ -3,6 +3,7 @@ package serviceimport ("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 errorif 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 = truediff --git a/internal/application/service/knowledge_process.go b/internal/application/service/knowledge_process.goindex 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 referencesvar storedImages []docparser.StoredImage+ var imageFileSvc interfaces.FileService+ var inlineParseErr errorif 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 = updatedMarkdownstoredImages = 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.gonew file mode 100644index 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 `[](https://example.com)` to illustrate a data URI."+ realImage := ""+ 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" ++ "\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" ++ "."+ 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 := ``+ 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 := "`[](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 := "\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 := ") + ")"+ 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.goindex 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 markdownServingURL 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 = md4if 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] = storedif 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() + extservingURL, 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("", servingURL) + markdown[m[1]:]- processed+++ rewrites = append(rewrites, inlineRewrite{m[0], m[1], fmt.Sprintf("", 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 = md2return 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 := falseif 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, payloadEndpayload := markdown[m[4]:m[5]]- mimeType := "image/" + mimeSubtypepayload = 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() + extservingURL, 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("", servingURL) + markdown[m[1]:]+ rewrites = append(rewrites, inlineRewrite{m[0], m[1], fmt.Sprintf("", 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 aboveif 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, payloadEndpayload := 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() + extservingURL, 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("", servingURL) + markdown[m[1]:]- processed+++ rewrites = append(rewrites, inlineRewrite{m[0], m[1], fmt.Sprintf("", 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 [](link_url) pattern where// an image is wrapped inside a Markdown link. We unwrap it to just // 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  form needs to be handled.func UnwrapLinkedImages(markdown string) string {- return reLinkedImage.ReplaceAllString(markdown, "")+ 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: .@@ -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() + extservingURL, 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 candiff --git a/internal/infrastructure/docparser/image_resolver_test.go b/internal/infrastructure/docparser/image_resolver_test.goindex 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 := ``+ 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{+ "``",+ "```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{+ "",+ `<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{+ "",+ `<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 := "[](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 = ""+ 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 != "\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"+ 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 "+ 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 "+ 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 := ""+ 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 := ".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 = ""+ }+ 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 != "\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 = ""+ }+ 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 = ""+ }+ 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 = ""+ if syntax == "markdown" {+ replacement = ""+ }+ } 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 != ""+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 := " + ")\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{}