@polymorphism-tech/morph-spec 8.34.2 → 8.35.1

package/framework/templates/dotnet/ai-kit/tests/Morph.AiKit.Tests/Fakes/InMemoryMediaStore.cs

@@ -0,0 +1,131 @@
+using System.Collections.Concurrent;
+using Morph.AiKit.Media;
+
+namespace Morph.AiKit.Tests.Fakes;
+
+/// <summary>
+/// Blob em memoria. <b>Conta as gravacoes</b> — e a contagem e o que prova que o
+/// <see cref="MediaStore"/> deduplicou em vez de regravar.
+/// </summary>
+/// <remarks>
+/// Um teste que so confira "o hash e o mesmo" nao distingue dedupe de regravacao: os dois
+/// produzem o mesmo hash. Por isso <see cref="Writes"/> existe.
+/// </remarks>
+public sealed class InMemoryMediaBlobs : IMediaBlobs
+{
+    private readonly ConcurrentDictionary<string, byte[]> _files = new(StringComparer.Ordinal);
+
+    /// <summary>Quantas gravacoes de verdade aconteceram.</summary>
+    public int Writes { get; private set; }
+
+    /// <summary>Os caminhos gravados.</summary>
+    public IReadOnlyCollection<string> Paths => _files.Keys.ToArray();
+
+    /// <inheritdoc />
+    public ValueTask<bool> ExistsAsync(string relativePath, CancellationToken cancellationToken)
+        => ValueTask.FromResult(_files.ContainsKey(relativePath));
+
+    /// <inheritdoc />
+    public ValueTask WriteAsync(string relativePath, ReadOnlyMemory<byte> bytes, CancellationToken cancellationToken)
+    {
+        Writes++;
+        _files[relativePath] = bytes.ToArray();
+        return ValueTask.CompletedTask;
+    }
+}
+
+/// <summary>
+/// <see cref="IMediaStore"/> em memoria, para os testes que precisam de UM storage e nao
+/// estao medindo o storage.
+/// </summary>
+public sealed class InMemoryMediaStore : IMediaStore
+{
+    private readonly MediaStore _inner;
+
+    /// <summary>Cria o store sobre um blob em memoria proprio.</summary>
+    public InMemoryMediaStore()
+    {
+        Blobs = new InMemoryMediaBlobs();
+        _inner = new MediaStore(Blobs);
+    }
+
+    /// <summary>O blob por baixo, para conferir gravacoes.</summary>
+    public InMemoryMediaBlobs Blobs { get; }
+
+    /// <inheritdoc />
+    public ValueTask<MediaStoreEntry> PutAsync(
+        ReadOnlyMemory<byte> bytes,
+        string mediaType,
+        CancellationToken cancellationToken)
+        => _inner.PutAsync(bytes, mediaType, cancellationToken);
+}
+
+/// <summary>Acervo de jobs em memoria — a costura com o banco do projeto, em teste.</summary>
+public sealed class InMemoryMediaJobs : IMediaJobRepository
+{
+    private readonly ConcurrentDictionary<Guid, MediaJob> _byId = new();
+
+    /// <summary>Quantas gravacoes aconteceram. Prova que o worker persistiu cada passo.</summary>
+    public int Saves { get; private set; }
+
+    /// <inheritdoc />
+    public ValueTask<MediaJob?> FindByIdempotencyKeyAsync(
+        MediaIdempotencyKey key,
+        CancellationToken cancellationToken)
+        => ValueTask.FromResult(_byId.Values.FirstOrDefault(j => j.IdempotencyKey == key));
+
+    /// <inheritdoc />
+    public ValueTask<MediaJob?> FindAsync(MediaJobId id, CancellationToken cancellationToken)
+        => ValueTask.FromResult(_byId.TryGetValue(id.Value, out var job) ? job : null);
+
+    /// <inheritdoc />
+    public ValueTask SaveAsync(MediaJob job, CancellationToken cancellationToken)
+    {
+        Saves++;
+        _byId[job.Id.Value] = job;
+        return ValueTask.CompletedTask;
+    }
+}
+
+/// <summary>Resolvedor de alias de teste: um alias, um binding.</summary>
+public sealed class StubAliasResolver : IMediaAliasResolver
+{
+    private readonly Dictionary<string, MediaAliasBinding> _bindings = new(StringComparer.Ordinal);
+
+    /// <summary>Declara um alias.</summary>
+    public StubAliasResolver With(MediaAliasBinding binding)
+    {
+        _bindings[binding.Alias] = binding;
+        return this;
+    }
+
+    /// <inheritdoc />
+    public MediaResult<MediaAliasBinding> Resolve(string alias)
+        => _bindings.TryGetValue(alias, out var binding)
+            ? MediaResult<MediaAliasBinding>.Ok(binding)
+            : MediaResult<MediaAliasBinding>.Fail(MediaErrorCode.InvalidRequest, $"alias '{alias}' nao existe.");
+}
+
+/// <summary>Teto de custo de teste: aceita ate um limite, e registra o que foi pedido.</summary>
+public sealed class CappedBudget(decimal cap) : IMediaBudget
+{
+    /// <summary>Os custos estimados que chegaram, na ordem.</summary>
+    public List<decimal> Seen { get; } = [];
+
+    /// <inheritdoc />
+    public ValueTask<bool> TryReserveAsync(
+        MediaRequest request,
+        decimal estimatedCostUsd,
+        CancellationToken cancellationToken)
+    {
+        Seen.Add(estimatedCostUsd);
+        return ValueTask.FromResult(estimatedCostUsd <= cap);
+    }
+}
+
+/// <summary>Relogio parado, para que o carimbo de tempo seja um fato do teste.</summary>
+public sealed class FixedMediaClock(DateTimeOffset now) : IMediaClock
+{
+    /// <inheritdoc />
+    public DateTimeOffset UtcNow { get; } = now;
+}

package/framework/templates/dotnet/ai-kit/tests/Morph.AiKit.Tests/MediaAccessibilityTests.cs

@@ -0,0 +1,133 @@
+using System.Reflection;
+using Morph.AiKit.Media;
+using Xunit;
+
+namespace Morph.AiKit.Tests;
+
+/// <summary>
+/// O canario da REGRA DURA de <c>ai-agents/media-pipeline.md</c>:
+/// <b>nunca gere midia dentro de um turno de conversa</b>.
+/// </summary>
+/// <remarks>
+/// <para>
+/// A regra nao e presa por prosa — e presa por ACESSIBILIDADE. O tipo que produz bytes e
+/// <c>internal</c> ao assembly; um handler de mensagem no projeto consumidor nao consegue
+/// nomea-lo, e o codigo nao compila. Este arquivo e o que mantem essa afirmacao verdadeira
+/// depois de qualquer refatoracao.
+/// </para>
+/// <para>
+/// <b>A mutacao foi rodada</b> (T10): tornar <c>IMediaProvider</c> publico derruba
+/// <see cref="TheTypeThatProducesBytesIsNotPublic"/> nomeando o defeito. Um canario que
+/// ninguem viu morder pode ser o canario errado.
+/// </para>
+/// <para>
+/// A leitura e por <b>reflexao sobre a assembly</b>, e nao por <c>grep</c> no fonte: o
+/// modificador que importa e o que sobreviveu a compilacao. Um <c>grep</c> por
+/// <c>"internal interface"</c> mediria o texto, e o texto e uma copia do objeto.
+/// </para>
+/// </remarks>
+public sealed class MediaAccessibilityTests
+{
+    private static readonly Assembly Kit = typeof(MediaJob).Assembly;
+
+    /// <summary>Os nomes que produzem, ou orquestram a producao de, bytes pagos.</summary>
+    public static TheoryData<string> ByteProducingTypes() =>
+    [
+        "Morph.AiKit.Media.IMediaProvider",
+        "Morph.AiKit.Media.Providers.OpenAIImageProvider",
+        "Morph.AiKit.Media.Providers.OpenAIImageGenerator",
+        "Morph.AiKit.Media.Providers.GoogleImageProvider",
+        "Morph.AiKit.Media.Providers.VeoVideoProvider",
+        "Morph.AiKit.Media.MediaWorker",
+        "Morph.AiKit.Media.MediaGenerator",
+        "Morph.AiKit.Media.MediaProviderCatalog",
+        "Morph.AiKit.Media.MediaArtifact",
+    ];
+
+    /// <summary>
+    /// A asserção literal do plano:
+    /// <c>typeof(MediaJob).Assembly.GetType("Morph.AiKit.Media.IMediaProvider")!.IsPublic == false</c>.
+    /// </summary>
+    [Fact]
+    public void TheTypeThatProducesBytesIsNotPublic()
+    {
+        var provider = Kit.GetType("Morph.AiKit.Media.IMediaProvider");
+
+        Assert.NotNull(provider);
+        Assert.False(
+            provider.IsPublic,
+            "IMediaProvider virou publico: um handler de mensagem passa a conseguir nomear o tipo que " +
+            "produz bytes, e a regra dura de ai-agents/media-pipeline.md deixa de ser presa pelo " +
+            "compilador. E prosa outra vez.");
+    }
+
+    /// <summary>Uma rodada por tipo: nenhum deles pode vazar para fora do assembly.</summary>
+    [Theory]
+    [MemberData(nameof(ByteProducingTypes))]
+    public void NoByteProducingTypeIsVisibleOutsideTheAssembly(string fullName)
+    {
+        var type = Kit.GetType(fullName);
+
+        Assert.NotNull(type);
+        Assert.False(type.IsPublic, $"{fullName} nao pode ser publico.");
+        Assert.False(type.IsNestedPublic, $"{fullName} nao pode ser aninhado publico.");
+    }
+
+    /// <summary>
+    /// O outro lado da mesma afirmacao: a superficie publica EXISTE, e ela nunca devolve
+    /// bytes. Sem esta metade, tornar tudo internal passaria — e um subsistema inalcancavel
+    /// tambem esta errado.
+    /// </summary>
+    [Fact]
+    public void ThePublicEntryPointExistsAndNeverReturnsBytes()
+    {
+        var generator = Kit.GetType("Morph.AiKit.Media.IMediaGenerator");
+
+        Assert.NotNull(generator);
+        Assert.True(generator.IsPublic, "IMediaGenerator precisa ser publico — e a unica porta de entrada.");
+
+        foreach (var method in generator.GetMethods())
+        {
+            var returned = method.ReturnType.IsGenericType
+                ? method.ReturnType.GetGenericArguments()[0]
+                : method.ReturnType;
+
+            var payload = returned.IsGenericType ? returned.GetGenericArguments()[0] : returned;
+
+            Assert.True(
+                payload == typeof(MediaJobId) || payload == typeof(MediaJob),
+                $"IMediaGenerator.{method.Name} devolve '{payload.Name}'. A superficie publica devolve id " +
+                "de job ou o job — nunca bytes, stream, BinaryData ou URL de provider.");
+        }
+    }
+
+    /// <summary>
+    /// <see cref="MediaArtifact"/> — o registro que CARREGA os bytes — nao pode aparecer em
+    /// nenhuma assinatura publica do subsistema. Ele existe entre dois tipos internal.
+    /// </summary>
+    [Fact]
+    public void TheArtifactNeverAppearsInAPublicSignature()
+    {
+        var artifact = Kit.GetType("Morph.AiKit.Media.MediaArtifact");
+        Assert.NotNull(artifact);
+
+        var leaks = new List<string>();
+
+        foreach (var type in Kit.GetExportedTypes().Where(t => t.Namespace?.StartsWith("Morph.AiKit.Media", StringComparison.Ordinal) == true))
+        {
+            foreach (var method in type.GetMethods(BindingFlags.Public | BindingFlags.Instance | BindingFlags.Static | BindingFlags.DeclaredOnly))
+            {
+                if (Mentions(method.ReturnType, artifact) || method.GetParameters().Any(p => Mentions(p.ParameterType, artifact)))
+                {
+                    leaks.Add($"{type.FullName}.{method.Name}");
+                }
+            }
+        }
+
+        Assert.Empty(leaks);
+    }
+
+    private static bool Mentions(Type candidate, Type target)
+        => candidate == target
+            || (candidate.IsGenericType && candidate.GetGenericArguments().Any(a => Mentions(a, target)));
+}

package/framework/templates/dotnet/ai-kit/tests/Morph.AiKit.Tests/MediaAliasIsNotAnAgentTests.cs

@@ -0,0 +1,127 @@
+using Morph.AiKit.Agents;
+using Morph.AiKit.Providers;
+using Morph.AiKit.Tests.Fakes;
+using Xunit;
+
+namespace Morph.AiKit.Tests;
+
+/// <summary>
+/// A companheira obrigatoria de <c>AgentApi.Images</c>/<c>AgentApi.Videos</c> existirem:
+/// <b>um alias de midia nao vira agente</b>.
+/// </summary>
+/// <remarks>
+/// <para>
+/// Um registry so e um vocabulario so de alias e a decisao (<c>decisions.md</c> D3) — e
+/// justamente por isso a recusa precisa existir. Sem ela, um alias de imagem passado por
+/// engano viraria um agente de chat apontando para um modelo que nao fala chat: a falha
+/// apareceria no primeiro turno, com uma mensagem do provider que nao diz o que aconteceu.
+/// </para>
+/// <para>
+/// Enum novo sem recusa e uma armadilha nova. Este arquivo e o que impede que ela volte.
+/// </para>
+/// </remarks>
+public sealed class MediaAliasIsNotAnAgentTests
+{
+    private const string MediaAliasDocument = """
+    {
+      "version": "2.0",
+      "defaultAlias": "texto",
+      "aliases": {
+        "texto": {
+          "provider": "openai",
+          "model": "gpt-5.4",
+          "api": "responses",
+          "pricing": { "inputPerMTok": 1.25, "outputPerMTok": 10.0 }
+        },
+        "imagem": {
+          "provider": "openai",
+          "model": "gpt-image-2",
+          "api": "images",
+          "pricingWaiver": "tarifa de imagem cobra por imagem/qualidade, nao por token: ver MediaPricing."
+        },
+        "video": {
+          "provider": "google",
+          "model": "veo-3.1-fast-generate-preview",
+          "api": "videos",
+          "pricingWaiver": "tarifa de video cobra por segundo de saida: ver MediaPricing."
+        }
+      }
+    }
+    """;
+
+    private static AgentSpec Spec(string alias, AgentApi? api = null)
+        => new() { Alias = alias, Instructions = "voce e um agente de teste", Api = api };
+
+    /// <summary>O registry ACEITA <c>images</c> e <c>videos</c> — um vocabulario so de alias.</summary>
+    [Theory]
+    [InlineData("imagem", AgentApi.Images)]
+    [InlineData("video", AgentApi.Videos)]
+    public void TheRegistryUnderstandsTheMediaProtocols(string alias, AgentApi expected)
+    {
+        using var registry = ModelRegistry.FromJson(MediaAliasDocument, new FakeProviderClientFactory());
+
+        Assert.Equal(expected, registry.Resolve(alias).Api);
+    }
+
+    /// <summary>E a fabrica RECUSA, na construcao, com erro nomeado.</summary>
+    [Theory]
+    [InlineData("imagem")]
+    [InlineData("video")]
+    public void TheFactoryRefusesAMediaAliasByName(string alias)
+    {
+        using var registry = ModelRegistry.FromJson(MediaAliasDocument, new FakeProviderClientFactory());
+        var factory = new AgentFactory(registry);
+
+        var ex = Assert.Throws<AgentFactoryException>(() => factory.Create(Spec(alias)));
+
+        Assert.Equal(AgentFactoryError.MediaAliasIsNotAnAgent, ex.Reason);
+        Assert.Contains("EnqueueAsync", ex.Message, StringComparison.Ordinal);
+    }
+
+    /// <summary>
+    /// A recusa tambem cobre o caminho pela SPEC: um alias de conversa com
+    /// <c>Api = Images</c> na spec e a mesma confusao, pela outra porta.
+    /// </summary>
+    [Fact]
+    public void TheFactoryRefusesAMediaProtocolDeclaredOnTheSpec()
+    {
+        using var registry = ModelRegistry.FromJson(MediaAliasDocument, new FakeProviderClientFactory());
+        var factory = new AgentFactory(registry);
+
+        var ex = Assert.Throws<AgentFactoryException>(() => factory.Create(Spec("texto", AgentApi.Images)));
+
+        Assert.Equal(AgentFactoryError.MediaAliasIsNotAnAgent, ex.Reason);
+    }
+
+    /// <summary>Alias de conversa continua passando — a recusa nova nao pode ser um bloqueio geral.</summary>
+    [Fact]
+    public void AChatAliasStillBuildsAnAgent()
+    {
+        using var registry = ModelRegistry.FromJson(MediaAliasDocument, new FakeProviderClientFactory());
+        var factory = new AgentFactory(registry);
+
+        Assert.NotNull(factory.Create(Spec("texto")));
+    }
+
+    /// <summary>O predicado mora num lugar so — duas copias e como as duas discordam.</summary>
+    [Theory]
+    [InlineData(AgentApi.Responses, false)]
+    [InlineData(AgentApi.Chat, false)]
+    [InlineData(AgentApi.Images, true)]
+    [InlineData(AgentApi.Videos, true)]
+    public void IsMediaAnswersForEveryProtocol(AgentApi api, bool expected)
+        => Assert.Equal(expected, api.IsMedia());
+
+    /// <summary>Um <c>api</c> inventado continua sendo recusado na carga do documento.</summary>
+    [Fact]
+    public void AnUnknownApiIsStillRefusedWithTheFullListOfValidValues()
+    {
+        var document = MediaAliasDocument.Replace("\"api\": \"images\"", "\"api\": \"holograma\"", StringComparison.Ordinal);
+
+        var ex = Assert.Throws<ModelRegistryException>(
+            () => ModelRegistry.FromJson(document, new FakeProviderClientFactory()));
+
+        Assert.Contains("images", ex.Message, StringComparison.Ordinal);
+        Assert.Contains("videos", ex.Message, StringComparison.Ordinal);
+    }
+}

package/framework/templates/dotnet/ai-kit/tests/Morph.AiKit.Tests/MediaDisclosureTests.cs

@@ -0,0 +1,216 @@
+using System.Reflection;
+using Morph.AiKit.Media;
+using Xunit;
+
+namespace Morph.AiKit.Tests;
+
+/// <summary>
+/// Canários da MARCAÇÃO — a quarta afirmação da rubrica `media-claims`, e a última que este
+/// kit ainda prendia só por prosa.
+/// </summary>
+/// <remarks>
+/// <para>
+/// <b>A assimetria que estes testes fecham, medida:</b> a regra do turno de conversa estava
+/// presa por TIPO (`internal` + id de job em vez de bytes) e provada por mutação; custo e
+/// revisão humana, por ESTADO. A marcação — que é a obrigação legal, o art. 50 do AI Act que
+/// motivou a issue — estava escrita em `MediaJobState.cs` ("publicado, com a marcacao
+/// aplicada") e em `MediaRequest.cs` ("marcacao visivel obrigatoria"), e um `grep` por label,
+/// watermark ou disclosure no kit inteiro voltava <b>vazio</b>. Zero mecanismo.
+/// </para>
+/// <para>
+/// Uma rubrica que cobra de terceiros uma prova que o próprio exemplar não dá é o defeito que
+/// esta epic catalogou. Estes testes são o inverso literal dele.
+/// </para>
+/// <para>
+/// <b>Fronteira honesta:</b> nada aqui prova que o rótulo chegou aos olhos de alguém — a
+/// renderização é do aplicativo consumidor, e nenhum tipo em C# alcança um pixel. O que se
+/// prova é que a publicação <b>não acontece</b> sem a decisão registrada, com texto e
+/// superfície nomeados.
+/// </para>
+/// </remarks>
+public sealed class MediaDisclosureTests
+{
+    private static readonly DateTimeOffset T0 = new(2026, 9, 8, 12, 0, 0, TimeSpan.Zero);
+
+    private static MediaDisclosure Label => MediaDisclosure.Create("Imagem gerada por IA", "legenda", T0);
+
+    /// <summary>Um job aprovado, na finalidade pedida.</summary>
+    private static MediaJob Approved(MediaPurpose purpose)
+    {
+        var job = MediaJob.Create(
+            new MediaRequest("catalogo", "um sofa verde", purpose),
+            new MediaIdempotencyKey("chave"),
+            T0).StartGenerating().Value;
+
+        job = job.MarkGenerated(
+            new MediaHash("abc"),
+            "ab/c/abc.png",
+            new MediaProvenance("openai", "gpt-image-2", "p", null, [], "-", null, 0m, T0, true)).Value;
+
+        return job.Approve(MediaReview.ApprovedBy("lucas", T0)).Value;
+    }
+
+    // ---------------------------------------------------------------------------------
+    // A política, por finalidade — dado, não comentário
+    // ---------------------------------------------------------------------------------
+
+    /// <summary>Catálogo e marketing exigem marcação; rascunho não chega a publicar.</summary>
+    [Theory]
+    [InlineData(MediaPurpose.CatalogPhoto, true)]
+    [InlineData(MediaPurpose.Marketing, true)]
+    [InlineData(MediaPurpose.Draft, false)]
+    public void RequiresDisclosureIsDeclaredPerPurpose(MediaPurpose purpose, bool expected)
+        => Assert.Equal(expected, purpose.RequiresDisclosure());
+
+    /// <summary>Rascunho é a única finalidade não publicável.</summary>
+    [Theory]
+    [InlineData(MediaPurpose.CatalogPhoto, true)]
+    [InlineData(MediaPurpose.Marketing, true)]
+    [InlineData(MediaPurpose.Draft, false)]
+    public void OnlyDraftIsUnpublishable(MediaPurpose purpose, bool expected)
+        => Assert.Equal(expected, purpose.IsPublishable());
+
+    // ---------------------------------------------------------------------------------
+    // A porta: publicar sem marcação NÃO é um caminho
+    // ---------------------------------------------------------------------------------
+
+    /// <summary>
+    /// O caso central. Um job aprovado, de catálogo, sem marcação: <b>não publica</b>, e a
+    /// razão nomeia o que falta.
+    /// </summary>
+    [Theory]
+    [InlineData(MediaPurpose.CatalogPhoto)]
+    [InlineData(MediaPurpose.Marketing)]
+    public void PublishFailsWithoutADisclosureWhenThePurposeDemandsOne(MediaPurpose purpose)
+    {
+        var result = Approved(purpose).Publish(null, T0);
+
+        Assert.False(
+            result.IsSuccess,
+            "publicar sem marcacao e o caminho que a obrigacao legal existe para fechar; " +
+            "se ele existe, a afirmacao da rubrica media-claims esta presa so por prosa");
+        Assert.Equal(MediaErrorCode.InvalidTransition, result.Error!.Code);
+        Assert.Contains("marcacao", result.Error.Message, StringComparison.OrdinalIgnoreCase);
+    }
+
+    /// <summary>Com a marcação, publica — e ela fica GRAVADA no job, não descartada.</summary>
+    [Fact]
+    public void PublishSucceedsWithADisclosureAndRecordsIt()
+    {
+        var published = Approved(MediaPurpose.CatalogPhoto).Publish(Label, T0);
+
+        Assert.True(published.IsSuccess);
+        Assert.Equal(MediaJobState.Published, published.Value.State);
+        Assert.Equal("Imagem gerada por IA", published.Value.Disclosure!.Text);
+        Assert.Equal("legenda", published.Value.Disclosure.Surface);
+        Assert.Equal(T0, published.Value.Disclosure.AppliedAt);
+    }
+
+    /// <summary>
+    /// Rascunho não publica, <b>nem com marcação e nem estando aprovado</b>. Era uma frase
+    /// num comentário XML; agora é uma recusa.
+    /// </summary>
+    [Fact]
+    public void ADraftNeverPublishesEvenApprovedAndLabelled()
+    {
+        var result = Approved(MediaPurpose.Draft).Publish(Label, T0);
+
+        Assert.False(result.IsSuccess);
+        Assert.Contains("nao publica", result.Error!.Message, StringComparison.OrdinalIgnoreCase);
+    }
+
+    /// <summary>
+    /// A ordem das portas importa: o estado vem antes da marcação. Um job NÃO aprovado, sem
+    /// marcação, tem de reclamar da revisão humana — mandar consertar a marcação de algo que
+    /// nem foi revisado manda consertar a coisa errada.
+    /// </summary>
+    [Fact]
+    public void TheStateGateIsReportedBeforeTheDisclosureGate()
+    {
+        var generated = MediaJob.Create(
+            new MediaRequest("catalogo", "p", MediaPurpose.CatalogPhoto),
+            new MediaIdempotencyKey("k"),
+            T0).StartGenerating().Value
+            .MarkGenerated(
+                new MediaHash("abc"), "ab/c/abc.png",
+                new MediaProvenance("openai", "m", "p", null, [], "-", null, 0m, T0, true)).Value;
+
+        var result = generated.Publish(null, T0);
+
+        Assert.False(result.IsSuccess);
+        Assert.Contains("Approved", result.Error!.Message, StringComparison.Ordinal);
+        Assert.DoesNotContain("marcacao", result.Error.Message, StringComparison.OrdinalIgnoreCase);
+    }
+
+    // ---------------------------------------------------------------------------------
+    // A marcação vazia é o campo preenchido "para passar"
+    // ---------------------------------------------------------------------------------
+
+    /// <summary>
+    /// <b>A construção não tem outra porta.</b> Este é o teste que o nome do anterior prometia
+    /// e não entregava.
+    /// </summary>
+    /// <remarks>
+    /// <para>
+    /// A primeira versão de <see cref="MediaDisclosure"/> era um record POSICIONAL, e record
+    /// posicional gera construtor <b>público</b>. A validação vivia só em
+    /// <see cref="MediaDisclosure.Create"/>, então um consumidor externo fazia
+    /// <c>new MediaDisclosure("", "", at)</c> e publicava com rótulo vazio — medido:
+    /// <c>IsSuccess=True State=Published</c>. O canário de então exercitava a FÁBRICA e passava
+    /// verde o tempo todo: media a copia, nao o objeto.
+    /// </para>
+    /// <para>
+    /// Por isso a asserção é por REFLEXÃO sobre o tipo. Ela não pode ser escrita como
+    /// <c>new MediaDisclosure(...)</c> — hoje isso nem compila, e é esse o ponto: uma asserção
+    /// que só existe enquanto o defeito existe não é canário.
+    /// </para>
+    /// </remarks>
+    [Fact]
+    public void TheTypeExposesNoPublicConstructor()
+    {
+        var publicCtors = typeof(MediaDisclosure)
+            .GetConstructors(BindingFlags.Public | BindingFlags.Instance);
+
+        Assert.True(
+            publicCtors.Length == 0,
+            "MediaDisclosure nao pode ter construtor publico: ele contorna Create e deixa " +
+            "passar marcacao em branco — o campo preenchido 'para passar' que este tipo existe " +
+            "para impedir. Record POSICIONAL gera um; use record com construtor privado, como " +
+            "MediaReview. Encontrados: " + string.Join(" | ", publicCtors.Select(c => c.ToString())));
+    }
+
+    /// <summary>Texto ou superfície em branco é recusado pela única porta que existe.</summary>
+    [Theory]
+    [InlineData("", "legenda")]
+    [InlineData("   ", "legenda")]
+    [InlineData("Imagem gerada por IA", "")]
+    [InlineData("Imagem gerada por IA", "   ")]
+    public void ABlankDisclosureIsRefusedByTheOnlyFactory(string text, string surface)
+        => Assert.Throws<ArgumentException>(() => MediaDisclosure.Create(text, surface, T0));
+
+    /// <summary>
+    /// A superfície é obrigatória junto do texto: "marcado" sem dizer ONDE não responde se
+    /// alguém consegue ver.
+    /// </summary>
+    [Fact]
+    public void TheDisclosureCarriesBothTheTextAndWhereItAppears()
+    {
+        var disclosure = MediaDisclosure.Create("Gerado por IA", "sobreposicao", T0);
+
+        Assert.Equal("Gerado por IA", disclosure.Text);
+        Assert.Equal("sobreposicao", disclosure.Surface);
+    }
+
+    /// <summary>Uma publicação recusada não muda o job — o registro continua imutável.</summary>
+    [Fact]
+    public void ARefusedPublishLeavesTheJobUntouched()
+    {
+        var job = Approved(MediaPurpose.Marketing);
+
+        _ = job.Publish(null, T0);
+
+        Assert.Equal(MediaJobState.Approved, job.State);
+        Assert.Null(job.Disclosure);
+        Assert.Null(job.PublishedAt);
+    }
+}