@sanity/ailf 4.0.7 → 4.2.0

package/dist/_vendor/ailf-core/types/api-requests.d.ts

@@ -0,0 +1,159 @@
+/**
+ * API Service Gateway request envelope types.
+ *
+ * These types describe the HTTP request bodies the API gateway accepts on
+ * its public-facing routes. They live in core (not in packages/api/src/) so
+ * the gateway's Zod validators can `satisfies z.ZodType<...>` against them
+ * — making the parse-output → domain-type contract a compile-time gate
+ * rather than a runtime assumption (D0045 / W0187).
+ *
+ * The shapes here are intentionally a LOOSE subset of the canonical domain
+ * types they relate to:
+ *
+ *   - `ValidateConfigRequest.config` overlaps with `ModelsConfig`, but the
+ *     API surface accepts string[] for modes (not branded EvalMode[]) and
+ *     all fields are optional. This is a deliberate gateway contract — the
+ *     route's job is to validate the user's input, not to require a fully
+ *     domain-shaped payload.
+ *   - `ValidateTaskDef` overlaps with `GeneralizedTaskDefinition` but uses
+ *     the older flat shape (`featureArea`, `canonicalDocs`) instead of the
+ *     mode-discriminated union. Harmonizing these is tracked separately —
+ *     out of scope for W0187.
+ *
+ * Any fields not on these types are rejected by the gateway's validators
+ * and won't reach domain code; the satisfies clause is what pins that
+ * contract in place.
+ */
+/**
+ * POST /v1/validate/config — request envelope.
+ * @see packages/api/src/schemas/validate-requests.ts
+ */
+export interface ValidateConfigRequest {
+    config: {
+        defaults?: Record<string, unknown>;
+        grader?: {
+            id: string;
+            label?: string;
+        };
+        maxConcurrency?: number;
+        models?: {
+            config?: Record<string, unknown>;
+            id: string;
+            label?: string;
+            modes?: string[];
+        }[];
+    };
+}
+/**
+ * Canonical doc reference used inside `ValidateTaskDef.canonicalDocs`.
+ * Mirrors the four shapes the API gateway accepts.
+ */
+export type ValidateTaskCanonicalDocRef = {
+    reason?: string;
+    slug: string;
+} | {
+    path: string;
+    reason?: string;
+} | {
+    id: string;
+    path?: string;
+    reason?: string;
+    slug?: string;
+} | {
+    perspective: string;
+    reason?: string;
+};
+/**
+ * Assertion definition accepted by the API gateway's task validator.
+ * Either an `llm-rubric` shape with explicit fields, or a generic
+ * type+value pair for non-LLM assertions.
+ */
+export type ValidateTaskAssertionDef = {
+    criteria: string[];
+    template: string;
+    type: "llm-rubric";
+    weight?: number;
+} | {
+    type: string;
+    value?: unknown;
+    weight?: number;
+};
+/**
+ * The "task definition" shape accepted by POST /v1/validate/task.
+ *
+ * Distinct from `GeneralizedTaskDefinition` (the mode-discriminated
+ * canonical task type): this is the older flat shape preserved at the
+ * API surface. Harmonization tracked separately.
+ */
+export interface ValidateTaskDef {
+    assertions: ValidateTaskAssertionDef[];
+    baseline?: {
+        enabled?: boolean;
+        rubric?: "abbreviated" | "full" | "none";
+    };
+    canonicalDocs: ValidateTaskCanonicalDocRef[];
+    description: string;
+    docCoverage: boolean;
+    extraVars?: Record<string, unknown>;
+    featureArea: string;
+    id: string;
+    referenceSolution: string;
+    taskPrompt: string;
+}
+/**
+ * POST /v1/validate/task — request envelope.
+ * @see packages/api/src/schemas/validate-requests.ts
+ */
+export interface ValidateTaskRequest {
+    strict: boolean;
+    tasks: ValidateTaskDef[];
+}
+/**
+ * POST /v1/validate/source — request envelope.
+ * @see packages/api/src/schemas/validate-requests.ts
+ */
+export interface ValidateSourceRequest {
+    source: {
+        baseUrl?: string;
+        dataset?: string;
+        projectId?: string;
+        token?: string;
+    };
+}
+/**
+ * POST /v1/lookup-doc — request envelope.
+ * @see packages/api/src/schemas/lookup-request.ts
+ */
+export interface LookupDocRequest {
+    keyword: string;
+    limit: number;
+    source: string;
+}
+/**
+ * Inline-score-or-report-id reference used by `CompareRequest`.
+ *
+ * Either:
+ *   - A partial inline score summary (used by the gateway's compare()
+ *     endpoint without a Content Lake round-trip), with `passthrough`
+ *     extra fields preserved, or
+ *   - A string report ID (the gateway fetches the corresponding
+ *     `ScoreSummary` from Content Lake before comparing).
+ */
+export type CompareScoreSummaryRef = string | {
+    [extra: string]: unknown;
+    features?: Record<string, unknown>;
+    overall: {
+        [extra: string]: unknown;
+        areaCount: number;
+        avgScore: number;
+    };
+};
+/**
+ * POST /v1/compare — request envelope.
+ * @see packages/api/src/schemas/compare-request.ts
+ */
+export interface CompareRequest {
+    baseline: CompareScoreSummaryRef;
+    experiment: CompareScoreSummaryRef;
+    threshold: number;
+}

package/dist/_vendor/ailf-core/types/api-requests.js

@@ -0,0 +1,27 @@
+/**
+ * API Service Gateway request envelope types.
+ *
+ * These types describe the HTTP request bodies the API gateway accepts on
+ * its public-facing routes. They live in core (not in packages/api/src/) so
+ * the gateway's Zod validators can `satisfies z.ZodType<...>` against them
+ * — making the parse-output → domain-type contract a compile-time gate
+ * rather than a runtime assumption (D0045 / W0187).
+ *
+ * The shapes here are intentionally a LOOSE subset of the canonical domain
+ * types they relate to:
+ *
+ *   - `ValidateConfigRequest.config` overlaps with `ModelsConfig`, but the
+ *     API surface accepts string[] for modes (not branded EvalMode[]) and
+ *     all fields are optional. This is a deliberate gateway contract — the
+ *     route's job is to validate the user's input, not to require a fully
+ *     domain-shaped payload.
+ *   - `ValidateTaskDef` overlaps with `GeneralizedTaskDefinition` but uses
+ *     the older flat shape (`featureArea`, `canonicalDocs`) instead of the
+ *     mode-discriminated union. Harmonizing these is tracked separately —
+ *     out of scope for W0187.
+ *
+ * Any fields not on these types are rejected by the gateway's validators
+ * and won't reach domain code; the satisfies clause is what pins that
+ * contract in place.
+ */
+export {};

package/dist/_vendor/ailf-core/types/generalized-task.d.ts

@@ -97,6 +97,19 @@ export interface TaskOptions {
     /** Arbitrary Promptfoo overrides (escape hatch) */
     promptfooOverrides?: Record<string, unknown>;
 }
+/**
+ * Variable keys reserved by the AILF compilers. Populated automatically
+ * from canonical task fields; forbidden in `prompt.vars` to prevent silent
+ * override of canonical values.
+ */
+export type ReservedPromptVarKey = "task" | "docs" | "__featureArea";
+/**
+ * Variables for prompt-template interpolation. Freeform extras are
+ * allowed; reserved keys (see {@link ReservedPromptVarKey}) are forbidden.
+ */
+export type PromptVars = Record<string, unknown> & {
+    [K in ReservedPromptVarKey]?: never;
+};
 /** Fields shared by all task modes */
 export interface TaskCommonFields {
     /** Unique task identifier */
@@ -121,7 +134,11 @@ export interface TaskCommonFields {
     providers?: TaskProviderConfig[];
     /** Task-level execution options */
     options?: TaskOptions;
-    /** Prompt configuration */
+    /**
+     * Prompt configuration. Reserved `vars` keys (see
+     * {@link ReservedPromptVarKey}) are forbidden — use `prompt.text` for
+     * the prompt body and `context.docs` for documentation references.
+     */
     prompt?: {
         /** Named prompt template */
         template?: string;
@@ -129,8 +146,8 @@ export interface TaskCommonFields {
         text?: string;
         /** System message override */
         systemMessage?: string;
-        /** Variables for template interpolation */
-        vars?: Record<string, unknown>;
+        /** Variables for template interpolation (reserved keys forbidden) */
+        vars?: PromptVars;
     };
     /** Arbitrary metadata */
     metadata?: Record<string, unknown>;

package/dist/_vendor/ailf-core/types/index.d.ts

@@ -23,9 +23,12 @@ export { evalModeType } from "./eval-mode-config.js";
 export type { DependencyEdge, ResolvedFixture, TaskGraph, TaskNode, } from "./task-graph.js";
 export type { VariableDeclaration, VariableEnvelope, VariableProvenance, VariableSource, } from "./variable-envelope.js";
 export type { EvalTrace, ToolCallCategory, ToolCallRecord, TraceEvent, TraceSpan, TraceTokenUsage, } from "./trace.js";
+export type { CompareRequest, CompareScoreSummaryRef, LookupDocRequest, ValidateConfigRequest, ValidateSourceRequest, ValidateTaskAssertionDef, ValidateTaskCanonicalDocRef, ValidateTaskDef, ValidateTaskRequest, } from "./api-requests.js";
+export type { AilfEvalWorkflow, AilfEvalWorkflowJob, AilfEvalWorkflowStep, RepoAgenticConfig, RepoArtifactsConfig, RepoConfig, RepoExecutionConfig, RepoOutputConfig, RepoOwnerConfig, RepoPublishConfig, RepoReportStoreConfig, RepoSourceConfig, RepoTaskSourceConfig, RepoTriggersConfig, ScheduleTriggerConfig, TriggerConfig, TriggerMode, } from "./repo-config.js";
+export type { PipelineRequest, PipelineRequestCallback, PipelineRequestCallerExecutor, PipelineRequestCallerGit, PipelineRequestCallerOwner, PipelineRequestDebug, PipelineRequestTaskSource, } from "./pipeline-request.js";
 export type { ArtifactId, AssociationAxis, AssociationValues, Brand, EntryKey, Err, FixtureId, IdValidationError, NewReportId, Ok, ProviderId, PromptId, Result, ResultId, RubricId, RunFingerprint, RunId, SuiteId, TaskId, TaskSlug, TraceId, } from "./branded-ids.js";
 export { err, fixtureId, generateRunId, ok, providerId, resultId, runId, suiteId, taskId, traceId, } from "./branded-ids.js";
-export type { AgentHarnessTaskDefinition, ContentLakeAuthorableMode, ContentLakeAuthorableTask, CustomTaskDefinition, GeneralizedAssertionDefinition, GeneralizedDocRef, GeneralizedTaskDefinition, GeneralizedTemplatedAssertion, GeneralizedValueAssertion, IdDocRef, KnowledgeProbeTaskDefinition, LiteracyTaskDefinition, MCPServerTaskDefinition, PathDocRef, PerspectiveDocRef, RubricRef, SlugDocRef, TaskCommonFields, TaskDifficulty, TaskOptions, TaskProviderConfig, TaskStatus, } from "./generalized-task.js";
+export type { AgentHarnessTaskDefinition, ContentLakeAuthorableMode, ContentLakeAuthorableTask, CustomTaskDefinition, GeneralizedAssertionDefinition, GeneralizedDocRef, GeneralizedTaskDefinition, GeneralizedTemplatedAssertion, GeneralizedValueAssertion, IdDocRef, KnowledgeProbeTaskDefinition, LiteracyTaskDefinition, MCPServerTaskDefinition, PromptVars, PathDocRef, PerspectiveDocRef, ReservedPromptVarKey, RubricRef, SlugDocRef, TaskCommonFields, TaskDifficulty, TaskOptions, TaskProviderConfig, TaskStatus, } from "./generalized-task.js";
 type DocumentRef = _DocumentRef;
 /** Aggregated retrieval metrics for a feature area */
 export interface AreaRetrievalMetrics {

package/dist/_vendor/ailf-core/types/pipeline-request.d.ts

@@ -0,0 +1,112 @@
+/**
+ * Pipeline-request domain types.
+ *
+ * Authored independently of `PipelineRequestSchema` in
+ * `packages/core/src/schemas/pipeline-request.ts` so the schema can
+ * `satisfies z.ZodType<PipelineRequest>` against this type — making
+ * schema/type drift a compile error rather than a silent regression
+ * (D0045 / W0187).
+ *
+ * `PipelineRequestSchema` is the universal pipeline invocation contract,
+ * shared between the API gateway (POST /v1/pipeline), the CLI (`--config`
+ * flag), and GitHub Actions workflows (`repository_dispatch` payload).
+ *
+ * Names here are prefixed `PipelineRequest*` to avoid colliding with the
+ * existing `DebugOptions` in `core/types/index.ts`, which has a stricter
+ * (required `enabled`) shape used by other pipeline code.
+ */
+import type { LiteracyVariant, RawEvalMode, RunClassification, RunExecutorSurface } from "../../ailf-shared/index.d.ts";
+/** Debug-mode options as accepted on the wire (looser than core's `DebugOptions`). */
+export interface PipelineRequestDebug {
+    enabled?: boolean;
+    firstN?: number;
+    pattern?: string;
+    sample?: number;
+}
+/** Webhook callback target for API-triggered evaluations. */
+export interface PipelineRequestCallback {
+    headers?: Record<string, string>;
+    url: string;
+}
+/**
+ * Git context from the *calling* repository (not the AILF runner repo).
+ * Carries provenance across cross-repo dispatches.
+ */
+export interface PipelineRequestCallerGit {
+    branch?: string;
+    prNumber?: number;
+    repo: string;
+    sha?: string;
+}
+/**
+ * Caller-side `RunOwner` payload (D0037). Team is required; individual
+ * optional.
+ */
+export interface PipelineRequestCallerOwner {
+    individual?: string;
+    team: string;
+}
+/**
+ * Caller-side executor payload — user variant only. System executors are
+ * always server-detected; the wire format excludes them. The Zod schema
+ * is `.strict()` to reject any unknown key (PII guard).
+ */
+export interface PipelineRequestCallerExecutor {
+    githubActor?: string;
+    name?: string;
+    surface: RunExecutorSurface;
+    type: "user";
+}
+/** Task-source override (W0077 Phase 6h) — mirrors `RepoConfig.taskSource`. */
+export interface PipelineRequestTaskSource {
+    repoTasksPath?: string;
+    type?: "content-lake" | "repo";
+}
+/**
+ * The universal pipeline invocation contract.
+ *
+ * The Zod schema at `packages/core/src/schemas/pipeline-request.ts`
+ * (`PipelineRequestSchema`) asserts `satisfies z.ZodType<PipelineRequest>`
+ * against this type. Field set must match the schema exactly.
+ */
+export interface PipelineRequest {
+    allowedOrigins?: string[];
+    areas?: string[];
+    backend?: "cloud-run" | "github-actions";
+    callback?: PipelineRequestCallback;
+    callerGit?: PipelineRequestCallerGit;
+    changedDocs?: string[];
+    classification?: RunClassification;
+    compare?: boolean;
+    compareBaseline?: string;
+    compareThreshold?: number;
+    concurrency?: number;
+    dataset?: string;
+    debug?: PipelineRequestDebug | boolean;
+    executor?: PipelineRequestCallerExecutor;
+    gapAnalysis?: boolean;
+    graderReplications?: number;
+    headers?: Record<string, string>;
+    inlineTasks?: Record<string, unknown>[];
+    jobId?: string;
+    labels?: string[];
+    mode?: RawEvalMode;
+    noAutoScope?: boolean;
+    noCache?: boolean;
+    noRemoteCache?: boolean;
+    owner?: PipelineRequestCallerOwner;
+    perspective?: string;
+    presets?: string[];
+    projectId?: string;
+    publish?: boolean;
+    publishTag?: string;
+    purpose?: string;
+    searchMode?: "off" | "open" | "origin-only";
+    source?: string;
+    sourceReportId?: string;
+    taskMode?: "content-lake" | "inline";
+    taskSource?: PipelineRequestTaskSource;
+    tasks?: string[];
+    urls?: string[];
+    variant?: LiteracyVariant;
+}

package/dist/_vendor/ailf-core/types/pipeline-request.js

@@ -0,0 +1,18 @@
+/**
+ * Pipeline-request domain types.
+ *
+ * Authored independently of `PipelineRequestSchema` in
+ * `packages/core/src/schemas/pipeline-request.ts` so the schema can
+ * `satisfies z.ZodType<PipelineRequest>` against this type — making
+ * schema/type drift a compile error rather than a silent regression
+ * (D0045 / W0187).
+ *
+ * `PipelineRequestSchema` is the universal pipeline invocation contract,
+ * shared between the API gateway (POST /v1/pipeline), the CLI (`--config`
+ * flag), and GitHub Actions workflows (`repository_dispatch` payload).
+ *
+ * Names here are prefixed `PipelineRequest*` to avoid colliding with the
+ * existing `DebugOptions` in `core/types/index.ts`, which has a stricter
+ * (required `enabled`) shape used by other pipeline code.
+ */
+export {};

package/dist/_vendor/ailf-core/types/repo-config.d.ts

@@ -0,0 +1,146 @@
+/**
+ * Repo-level configuration types for the AI Literacy Framework.
+ *
+ * These describe `.ailf/config.yaml` (`RepoConfig`) and the structural
+ * contract on `.github/workflows/ailf-eval.yml` (`AilfEvalWorkflow`) used
+ * by `ailf init` and the Tier 1 init contract test.
+ *
+ * Authored independently of the Zod schemas in
+ * `packages/eval/src/adapters/task-sources/repo-schemas.ts` so the schemas
+ * can `satisfies z.ZodType<...>` against them — making schema/type drift a
+ * compile error rather than a silent regression (D0045 / W0187).
+ *
+ * Note on optionality: schema fields declared with `.optional()` produce
+ * `T | undefined` from `z.infer`; we mirror that with `?:` properties.
+ * Top-level `RepoConfig` itself has all optional groups because a
+ * `.ailf/config.yaml` may legitimately omit any of them.
+ */
+/** Mode of an evaluation trigger — drives whether the run executes or just validates. */
+export type TriggerMode = "validate-only" | "eval";
+export interface TriggerConfig {
+    blocking?: boolean;
+    compare?: boolean;
+    mode: TriggerMode;
+    notify?: boolean;
+    paths?: string[];
+}
+export interface ScheduleTriggerConfig extends TriggerConfig {
+    cron: string;
+}
+/** Documentation source — which Sanity project's docs the eval reads. */
+export interface RepoSourceConfig {
+    baseUrl?: string;
+    dataset?: string;
+    projectId?: string;
+    studioOrigin?: string;
+}
+/** Report-store destination — which Sanity project receives `ailf.report` documents. */
+export interface RepoReportStoreConfig {
+    dataset: string;
+    projectId: string;
+}
+/** Publish policy — when `ailf run` writes a report without an explicit flag. */
+export interface RepoPublishConfig {
+    auto?: "always" | "full-runs" | "never";
+    tag?: string;
+}
+/** Execution-tier knobs — replaces the retired `--concurrency` / `--api-url` flags. */
+export interface RepoExecutionConfig {
+    apiUrl?: string;
+    concurrency?: number;
+    gapAnalysis?: boolean;
+    graderReplications?: number;
+}
+/** Where the pipeline writes results (replaces `--output-dir`). */
+export interface RepoOutputConfig {
+    dir?: string;
+}
+/** Run-attribution defaults (replaces `--owner-team` / `--owner-individual`). */
+export interface RepoOwnerConfig {
+    individual?: string;
+    team?: string;
+}
+/** Agentic-mode runtime config (replaces `--header` / `--allowed-origin`). */
+export interface RepoAgenticConfig {
+    allowedOrigins?: string[];
+    headers?: Record<string, string>;
+}
+/** Artifact-writer config (replaces `--no-artifacts` / `--artifacts-dir` / `--artifacts-exclude`). */
+export interface RepoArtifactsConfig {
+    dir?: string;
+    enabled?: boolean;
+    exclude?: string[];
+}
+/** Task-source config (replaces `--task-source` / `--repo-tasks-path`). */
+export interface RepoTaskSourceConfig {
+    repoTasksPath?: string;
+    type?: "content-lake" | "repo";
+}
+/** Trigger overrides keyed by trigger name. */
+export interface RepoTriggersConfig {
+    main?: TriggerConfig;
+    pr?: TriggerConfig;
+    "pr-task-change"?: TriggerConfig;
+    schedule?: ScheduleTriggerConfig;
+}
+/**
+ * Parsed shape of `.ailf/config.yaml`.
+ *
+ * Every field is optional at the top level because a config file may omit
+ * any group. The Zod schema at `packages/eval/src/adapters/task-sources/repo-schemas.ts`
+ * (`RepoConfigSchema`) asserts `satisfies z.ZodType<RepoConfig>` against
+ * this type.
+ */
+export interface RepoConfig {
+    agentic?: RepoAgenticConfig;
+    artifacts?: RepoArtifactsConfig;
+    execution?: RepoExecutionConfig;
+    output?: RepoOutputConfig;
+    owner?: RepoOwnerConfig;
+    publish?: RepoPublishConfig;
+    reportStore?: RepoReportStoreConfig;
+    source?: RepoSourceConfig;
+    taskSource?: RepoTaskSourceConfig;
+    triggers?: RepoTriggersConfig;
+}
+/**
+ * One step inside a GitHub Actions workflow job. Loose by design — this is
+ * a structural contract, not a literal-byte one. Extra fields are accepted.
+ */
+export interface AilfEvalWorkflowStep {
+    [extra: string]: unknown;
+    env?: Record<string, unknown>;
+    id?: string;
+    if?: string;
+    name?: string;
+    run?: string;
+    uses?: string;
+    with?: Record<string, unknown>;
+}
+/**
+ * One job entry inside a GitHub Actions workflow. Loose by design.
+ */
+export interface AilfEvalWorkflowJob {
+    [extra: string]: unknown;
+    name?: string;
+    permissions?: Record<string, unknown>;
+    "runs-on": string | string[];
+    steps: AilfEvalWorkflowStep[];
+}
+/**
+ * Structural shape of the `ailf-eval.yml` workflow template emitted by
+ * `ailf init`. Validates the consumer-visible contract: a workflow with a
+ * non-empty `name`, an `on` trigger spec, and at least one job. The
+ * literal YAML body is intentionally not pinned — comments, step
+ * ordering, and option flags can shift without breaking consumers.
+ *
+ * The Zod schema at `packages/eval/src/adapters/task-sources/repo-schemas.ts`
+ * (`AilfEvalWorkflowSchema`) asserts `satisfies z.ZodType<AilfEvalWorkflow>`
+ * against this type.
+ */
+export interface AilfEvalWorkflow {
+    [extra: string]: unknown;
+    jobs: Record<string, AilfEvalWorkflowJob>;
+    name: string;
+    on: unknown;
+}

package/dist/_vendor/ailf-core/types/repo-config.js

@@ -0,0 +1,18 @@
+/**
+ * Repo-level configuration types for the AI Literacy Framework.
+ *
+ * These describe `.ailf/config.yaml` (`RepoConfig`) and the structural
+ * contract on `.github/workflows/ailf-eval.yml` (`AilfEvalWorkflow`) used
+ * by `ailf init` and the Tier 1 init contract test.
+ *
+ * Authored independently of the Zod schemas in
+ * `packages/eval/src/adapters/task-sources/repo-schemas.ts` so the schemas
+ * can `satisfies z.ZodType<...>` against them — making schema/type drift a
+ * compile error rather than a silent regression (D0045 / W0187).
+ *
+ * Note on optionality: schema fields declared with `.optional()` produce
+ * `T | undefined` from `z.infer`; we mirror that with `?:` properties.
+ * Top-level `RepoConfig` itself has all optional groups because a
+ * `.ailf/config.yaml` may legitimately omit any of them.
+ */
+export {};

package/dist/_vendor/ailf-shared/index.d.ts

@@ -9,11 +9,13 @@
  * from @sanity/ailf-core, @sanity/ailf, or
  * @sanity/ailf-studio. It is the leaf of the dependency graph.
  *
- * Re-exports are explicit (named) rather than `export *` so that the studio
- * tsup DTS bundle can statically resolve each symbol's canonical owner —
- * `export *` chains across many modules trip rollup-plugin-dts's "Ambiguous
- * external namespace resolution" warning even when no symbol actually
- * collides. See W0124.
+ * Barrel hygiene rule (D0045): re-exports are explicit (named) rather than
+ * `export *`. `export *` chains across many modules trip rollup-plugin-dts's
+ * "Ambiguous external namespace resolution" warning even when no symbol
+ * actually collides, and worse — silently change which module's runtime
+ * symbol downstream consumers receive. The regression caught by W0124 was
+ * generalized to the whole barrel under W0186; `barrel.test.ts` locks the
+ * surface against future regressions.
  */
 export { computeCanaryDrift, type CanaryDriftReport, type CanaryReportSlim, type DriftEntry, type DriftThresholds, type DriftVerdict, } from "./canary-drift.js";
 export { type DocumentRef } from "./document-ref.js";

package/dist/_vendor/ailf-shared/index.js

@@ -9,11 +9,13 @@
  * from @sanity/ailf-core, @sanity/ailf, or
  * @sanity/ailf-studio. It is the leaf of the dependency graph.
  *
- * Re-exports are explicit (named) rather than `export *` so that the studio
- * tsup DTS bundle can statically resolve each symbol's canonical owner —
- * `export *` chains across many modules trip rollup-plugin-dts's "Ambiguous
- * external namespace resolution" warning even when no symbol actually
- * collides. See W0124.
+ * Barrel hygiene rule (D0045): re-exports are explicit (named) rather than
+ * `export *`. `export *` chains across many modules trip rollup-plugin-dts's
+ * "Ambiguous external namespace resolution" warning even when no symbol
+ * actually collides, and worse — silently change which module's runtime
+ * symbol downstream consumers receive. The regression caught by W0124 was
+ * generalized to the whole barrel under W0186; `barrel.test.ts` locks the
+ * surface against future regressions.
  */
 export { computeCanaryDrift, } from "./canary-drift.js";
 export { FEATURE_FLAGS, } from "./feature-flags.js";

package/dist/adapters/api-client/types.d.ts

@@ -11,6 +11,8 @@
  * @see packages/api/src/routes/pipeline.ts — POST /v1/pipeline response
  * @see packages/api/src/routes/jobs.ts — GET /v1/jobs/:id response
  */
+import type { ValidationIssue } from "../../_vendor/ailf-core/index.d.ts";
+export type { ValidationIssue } from "../../_vendor/ailf-core/index.d.ts";
 /** Standard envelope fields present on every API response. */
 export interface ApiEnvelope {
     object: string;
@@ -59,11 +61,6 @@ export interface SubmitResponse extends ApiEnvelope {
     estimatedDurationMs?: number;
     runUrl?: string;
 }
-export interface ValidationIssue {
-    severity: string;
-    source: string;
-    message: string;
-}
 export interface ValidationResponse extends ApiEnvelope {
     object: "validation";
     valid: boolean;

package/dist/adapters/doc-fetchers/sanity-doc-fetcher.d.ts

@@ -21,13 +21,29 @@ export declare class SanityDocFetcher implements DocFetcher {
     private fetchInternal;
     private fetchManifest;
     /**
-     * Batch-resolve document ID refs to their article slugs.
+     * Batch-resolve document ID refs without filtering on `_type`.
      *
-     * This bridges IdDocRef entries into the slug-based fetch pipeline.
-     * Articles are queried by _id and their slugs are returned for use
-     * in the existing slug-based content map.
+     * Articles are routed back into the slug-flow (so manifest, perspective
+     * diffing, and overlay handling continue to work unchanged). Non-articles
+     * are rendered eagerly via the renderer registry — `typesReference` gets
+     * a high-fidelity formatter; anything else falls through to the default
+     * walker so authors can pin marketing pages, glossary entries, etc.
+     * without an AILF code change.
+     *
+     * Three log shapes:
+     *   - `info` — doc rendered with the default formatter (suggests a
+     *     dedicated renderer would improve fidelity)
+     *   - `warn` — registered renderer produced empty content (W0195 AC#3)
+     *   - `warn` — id had no matching document (existed/wrong tenant/typo)
+     */
+    private resolveIdRefs;
+    /**
+     * Fetch the raw body of a Sanity file asset URL, used by the
+     * `typesReference` renderer to inline typedoc JSON. Returns `null`
+     * on any HTTP/network failure rather than throwing — the renderer
+     * surfaces a placeholder so the rest of the context still renders.
      */
-    private resolveIdRefsToSlugs;
+    private fetchAttachmentBody;
     /**
      * Resolve path-based canonical doc references to their article slugs.
      *