@makaio/framework 1.0.0-dev-1783977266352 → 1.0.0-dev-1784154668798

package/dist/view-builder-DQiA4wDH.d.mts

@@ -0,0 +1,618 @@
+import { _ as SurfaceBindingRegistration, a as ResolvedArtifactContextWire$1, q as ArtifactRevision$1, z as ArtifactRelation } from "./context-resolution-D5jHK1w-.mjs";
+import { z } from "zod";
+import * as _$_makaio_contracts0 from "@makaio/framework/contracts";
+
+//#region core/contracts/src/materialization/definition.d.ts
+/**
+ * A surface binding definition with a serializable registration record.
+ *
+ * Created by {@link defineSurfaceBinding}. The definition retains the original
+ * options and produces a bus-transportable {@link SurfaceBindingRegistration}
+ * via `toRegistration()`.
+ *
+ * The interface is intentionally opaque: only `id` is exposed directly so
+ * that callers have a stable, lightweight handle. All other properties are
+ * accessible exclusively through `toRegistration()`, keeping the contract
+ * aligned with the bus registration shape.
+ */
+interface SurfaceBindingDefinition {
+  /** Stable identifier for this surface binding (e.g. `'github.status.field'`). */
+  readonly id: string;
+  /**
+   * Produces a serializable registration record suitable for bus transport.
+   * @returns A {@link SurfaceBindingRegistration} snapshot with `target`
+   *   deep-cloned and all array fields copied to prevent shared-reference
+   *   mutation.
+   */
+  readonly toRegistration: () => SurfaceBindingRegistration;
+}
+/**
+ * Options for {@link defineSurfaceBinding}.
+ *
+ * Structurally identical to {@link SurfaceBindingRegistration} — every field
+ * is included in the serializable registration output.
+ */
+type DefineSurfaceBindingOptions = SurfaceBindingRegistration;
+/**
+ * Creates a surface binding definition with a serializable registration.
+ *
+ * The returned definition exposes the `id` identifier directly and produces
+ * a bus-transportable {@link SurfaceBindingRegistration} via `toRegistration()`.
+ * The `target` object is deep-cloned via `structuredClone` (consistent with
+ * how {@link SurfaceBindingRegistry} clones at storage boundaries), and array
+ * fields (`appliesTo`) are defensively copied so callers cannot mutate the
+ * registration snapshot.
+ * @param options - Surface binding registration options including provider,
+ *   namespace, target, and entity classes the binding applies to.
+ * @returns A {@link SurfaceBindingDefinition} with a `toRegistration` method.
+ * @example
+ * ```ts
+ * export const githubStatusFieldBinding = defineSurfaceBinding({
+ *   id: 'github.status.field',
+ *   provider: 'github',
+ *   namespace: 'status',
+ *   target: { kind: 'field', name: 'Status' },
+ *   appliesTo: ['workpiece'],
+ *   valueMapping: { pending: 'In Progress', completed: 'Done' },
+ * });
+ * ```
+ */
+declare function defineSurfaceBinding(options: DefineSurfaceBindingOptions): SurfaceBindingDefinition;
+//#endregion
+//#region core/contracts/src/materialization/view-model.d.ts
+/**
+ * Closed set of artifact view detail levels.
+ *
+ * Levels order monotonically: `link < summary < full`. A field declared at
+ * `link` is available at every level; a field declared at `full` appears only
+ * when the full view is requested.
+ */
+declare const ArtifactViewLevelSchema: z.ZodEnum<{
+  link: "link";
+  full: "full";
+  summary: "summary";
+}>;
+/** Artifact view detail level. */
+type ArtifactViewLevel$1 = z.infer<typeof ArtifactViewLevelSchema>;
+/**
+ * A provider-neutral navigation link.
+ *
+ * Links may reference a framework artifact by its stable id, an external URL,
+ * or both. At least one locator (`artifactId` or `url`) should be present for
+ * the link to be useful, but the schema does not enforce exclusivity — both
+ * may coexist when an artifact has a known external counterpart.
+ * @param artifactId - Stable framework artifact identity (open string).
+ * @param url - External deep-link URL.
+ * @param label - Human-readable label for the link.
+ */
+declare const ArtifactViewLinkSchema: z.ZodObject<{
+  artifactId: z.ZodOptional<z.ZodString>;
+  url: z.ZodOptional<z.ZodString>;
+  label: z.ZodString;
+}, z.core.$strip>;
+/** A provider-neutral navigation link. */
+type ArtifactViewLink = z.infer<typeof ArtifactViewLinkSchema>;
+/**
+ * Summary section: a short prose description.
+ * @param type - Section discriminant. Always `'summary'`.
+ * @param title - Human-readable section heading.
+ * @param text - Plain-text summary content.
+ */
+declare const ArtifactViewSummarySectionSchema: z.ZodObject<{
+  type: z.ZodLiteral<"summary">;
+  title: z.ZodString;
+  text: z.ZodString;
+}, z.core.$strip>;
+/**
+ * Properties section: key-value metadata rows.
+ * @param type - Section discriminant. Always `'properties'`.
+ * @param title - Human-readable section heading.
+ * @param rows - Ordered key-value pairs.
+ */
+declare const ArtifactViewPropertiesSectionSchema: z.ZodObject<{
+  type: z.ZodLiteral<"properties">;
+  title: z.ZodString;
+  rows: z.ZodArray<z.ZodObject<{
+    label: z.ZodString;
+    value: z.ZodString;
+  }, z.core.$strip>>;
+}, z.core.$strip>;
+/**
+ * Table section: columnar data with optional row-level links.
+ * @param type - Section discriminant. Always `'table'`.
+ * @param title - Human-readable section heading.
+ * @param columns - Column header labels.
+ * @param rows - Table rows; each row carries an array of cell values and an
+ *   optional link that may reference a framework artifact or an external URL.
+ */
+declare const ArtifactViewTableSectionSchema: z.ZodObject<{
+  type: z.ZodLiteral<"table">;
+  title: z.ZodString;
+  columns: z.ZodArray<z.ZodString>;
+  rows: z.ZodArray<z.ZodObject<{
+    cells: z.ZodArray<z.ZodString>;
+    link: z.ZodOptional<z.ZodObject<{
+      artifactId: z.ZodOptional<z.ZodString>;
+      url: z.ZodOptional<z.ZodString>;
+      label: z.ZodString;
+    }, z.core.$strip>>;
+  }, z.core.$strip>>;
+}, z.core.$strip>;
+/**
+ * Relations section: grouped relation items with open type strings.
+ *
+ * Relation types remain open strings so that product-owned kinds and
+ * extensions can declare custom relation semantics without modifying
+ * the framework contract.
+ * @param type - Section discriminant. Always `'relations'`.
+ * @param title - Human-readable section heading.
+ * @param groups - Grouped relation items, each group keyed by an open relation
+ *   type string.
+ */
+declare const ArtifactViewRelationsSectionSchema: z.ZodObject<{
+  type: z.ZodLiteral<"relations">;
+  title: z.ZodString;
+  groups: z.ZodArray<z.ZodObject<{
+    type: z.ZodString;
+    items: z.ZodArray<z.ZodObject<{
+      artifactId: z.ZodOptional<z.ZodString>;
+      url: z.ZodOptional<z.ZodString>;
+      label: z.ZodString;
+    }, z.core.$strip>>;
+  }, z.core.$strip>>;
+}, z.core.$strip>;
+/**
+ * Evidence section: references to external evidence sources.
+ * @param type - Section discriminant. Always `'evidence'`.
+ * @param title - Human-readable section heading.
+ * @param items - Evidence items; `kind` and `id` are open strings to allow
+ *   product-defined evidence categories.
+ */
+declare const ArtifactViewEvidenceSectionSchema: z.ZodObject<{
+  type: z.ZodLiteral<"evidence">;
+  title: z.ZodString;
+  items: z.ZodArray<z.ZodObject<{
+    kind: z.ZodString;
+    id: z.ZodString;
+    locator: z.ZodOptional<z.ZodString>;
+  }, z.core.$strip>>;
+}, z.core.$strip>;
+/**
+ * Raw section: opaque JSON-safe data for inspection or debugging.
+ *
+ * The `json` field is validated recursively against the JSON value contract
+ * to ensure the view model remains serializable.
+ * @param type - Section discriminant. Always `'raw'`.
+ * @param title - Human-readable section heading.
+ * @param json - Arbitrary JSON-safe value.
+ */
+declare const ArtifactViewRawSectionSchema: z.ZodObject<{
+  type: z.ZodLiteral<"raw">;
+  title: z.ZodString;
+  json: z.ZodType<_$_makaio_contracts0.JsonValue, unknown, z.core.$ZodTypeInternals<_$_makaio_contracts0.JsonValue, unknown>>;
+}, z.core.$strip>;
+/**
+ * Code section: source code or structured text with a language hint.
+ * @param type - Section discriminant. Always `'code'`.
+ * @param title - Human-readable section heading.
+ * @param language - Language identifier (e.g. `'typescript'`, `'go'`). Open string.
+ * @param content - Source code content.
+ */
+declare const ArtifactViewCodeSectionSchema: z.ZodObject<{
+  type: z.ZodLiteral<"code">;
+  title: z.ZodString;
+  language: z.ZodString;
+  content: z.ZodString;
+}, z.core.$strip>;
+/**
+ * Diagram section: structured diagram source with a notation identifier.
+ *
+ * Currently only `'mermaid'` is supported as a notation, but the field is
+ * a literal to allow future additions through a discriminated union.
+ * @param type - Section discriminant. Always `'diagram'`.
+ * @param title - Human-readable section heading.
+ * @param notation - Diagram notation identifier. Currently only `'mermaid'`.
+ * @param source - Diagram source text.
+ */
+declare const ArtifactViewDiagramSectionSchema: z.ZodObject<{
+  type: z.ZodLiteral<"diagram">;
+  title: z.ZodString;
+  notation: z.ZodLiteral<"mermaid">;
+  source: z.ZodString;
+}, z.core.$strip>;
+/**
+ * Discriminated union of all artifact view section variants.
+ *
+ * The `type` field is the discriminant. Each variant carries its own typed
+ * payload; see the individual section schemas for details.
+ */
+declare const ArtifactViewSectionSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
+  type: z.ZodLiteral<"summary">;
+  title: z.ZodString;
+  text: z.ZodString;
+}, z.core.$strip>, z.ZodObject<{
+  type: z.ZodLiteral<"properties">;
+  title: z.ZodString;
+  rows: z.ZodArray<z.ZodObject<{
+    label: z.ZodString;
+    value: z.ZodString;
+  }, z.core.$strip>>;
+}, z.core.$strip>, z.ZodObject<{
+  type: z.ZodLiteral<"table">;
+  title: z.ZodString;
+  columns: z.ZodArray<z.ZodString>;
+  rows: z.ZodArray<z.ZodObject<{
+    cells: z.ZodArray<z.ZodString>;
+    link: z.ZodOptional<z.ZodObject<{
+      artifactId: z.ZodOptional<z.ZodString>;
+      url: z.ZodOptional<z.ZodString>;
+      label: z.ZodString;
+    }, z.core.$strip>>;
+  }, z.core.$strip>>;
+}, z.core.$strip>, z.ZodObject<{
+  type: z.ZodLiteral<"relations">;
+  title: z.ZodString;
+  groups: z.ZodArray<z.ZodObject<{
+    type: z.ZodString;
+    items: z.ZodArray<z.ZodObject<{
+      artifactId: z.ZodOptional<z.ZodString>;
+      url: z.ZodOptional<z.ZodString>;
+      label: z.ZodString;
+    }, z.core.$strip>>;
+  }, z.core.$strip>>;
+}, z.core.$strip>, z.ZodObject<{
+  type: z.ZodLiteral<"evidence">;
+  title: z.ZodString;
+  items: z.ZodArray<z.ZodObject<{
+    kind: z.ZodString;
+    id: z.ZodString;
+    locator: z.ZodOptional<z.ZodString>;
+  }, z.core.$strip>>;
+}, z.core.$strip>, z.ZodObject<{
+  type: z.ZodLiteral<"raw">;
+  title: z.ZodString;
+  json: z.ZodType<_$_makaio_contracts0.JsonValue, unknown, z.core.$ZodTypeInternals<_$_makaio_contracts0.JsonValue, unknown>>;
+}, z.core.$strip>, z.ZodObject<{
+  type: z.ZodLiteral<"code">;
+  title: z.ZodString;
+  language: z.ZodString;
+  content: z.ZodString;
+}, z.core.$strip>, z.ZodObject<{
+  type: z.ZodLiteral<"diagram">;
+  title: z.ZodString;
+  notation: z.ZodLiteral<"mermaid">;
+  source: z.ZodString;
+}, z.core.$strip>], "type">;
+/** Any artifact view section variant. */
+type ArtifactViewSection = z.infer<typeof ArtifactViewSectionSchema>;
+/** Summary section. */
+type ArtifactViewSummarySection = z.infer<typeof ArtifactViewSummarySectionSchema>;
+/** Properties section. */
+type ArtifactViewPropertiesSection = z.infer<typeof ArtifactViewPropertiesSectionSchema>;
+/** Table section. */
+type ArtifactViewTableSection = z.infer<typeof ArtifactViewTableSectionSchema>;
+/** Relations section. */
+type ArtifactViewRelationsSection = z.infer<typeof ArtifactViewRelationsSectionSchema>;
+/** Evidence section. */
+type ArtifactViewEvidenceSection = z.infer<typeof ArtifactViewEvidenceSectionSchema>;
+/** Raw section. */
+type ArtifactViewRawSection = z.infer<typeof ArtifactViewRawSectionSchema>;
+/** Code section. */
+type ArtifactViewCodeSection = z.infer<typeof ArtifactViewCodeSectionSchema>;
+/** Diagram section. */
+type ArtifactViewDiagramSection = z.infer<typeof ArtifactViewDiagramSectionSchema>;
+/**
+ * Provider-neutral artifact view model.
+ *
+ * Contains semantic content and navigation, not Markdown, provider-specific
+ * field names, or renderer-specific layout directives. The model is
+ * JSON-safe: every value in every section must survive a JSON round-trip.
+ * @param title - Human-readable title for the artifact view.
+ * @param summary - Optional prose summary.
+ * @param navigation - Optional ordered set of navigation links.
+ * @param sections - Ordered array of typed sections.
+ */
+declare const ArtifactViewModelSchema$1: z.ZodObject<{
+  title: z.ZodString;
+  summary: z.ZodOptional<z.ZodString>;
+  navigation: z.ZodOptional<z.ZodArray<z.ZodObject<{
+    artifactId: z.ZodOptional<z.ZodString>;
+    url: z.ZodOptional<z.ZodString>;
+    label: z.ZodString;
+  }, z.core.$strip>>>;
+  sections: z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
+    type: z.ZodLiteral<"summary">;
+    title: z.ZodString;
+    text: z.ZodString;
+  }, z.core.$strip>, z.ZodObject<{
+    type: z.ZodLiteral<"properties">;
+    title: z.ZodString;
+    rows: z.ZodArray<z.ZodObject<{
+      label: z.ZodString;
+      value: z.ZodString;
+    }, z.core.$strip>>;
+  }, z.core.$strip>, z.ZodObject<{
+    type: z.ZodLiteral<"table">;
+    title: z.ZodString;
+    columns: z.ZodArray<z.ZodString>;
+    rows: z.ZodArray<z.ZodObject<{
+      cells: z.ZodArray<z.ZodString>;
+      link: z.ZodOptional<z.ZodObject<{
+        artifactId: z.ZodOptional<z.ZodString>;
+        url: z.ZodOptional<z.ZodString>;
+        label: z.ZodString;
+      }, z.core.$strip>>;
+    }, z.core.$strip>>;
+  }, z.core.$strip>, z.ZodObject<{
+    type: z.ZodLiteral<"relations">;
+    title: z.ZodString;
+    groups: z.ZodArray<z.ZodObject<{
+      type: z.ZodString;
+      items: z.ZodArray<z.ZodObject<{
+        artifactId: z.ZodOptional<z.ZodString>;
+        url: z.ZodOptional<z.ZodString>;
+        label: z.ZodString;
+      }, z.core.$strip>>;
+    }, z.core.$strip>>;
+  }, z.core.$strip>, z.ZodObject<{
+    type: z.ZodLiteral<"evidence">;
+    title: z.ZodString;
+    items: z.ZodArray<z.ZodObject<{
+      kind: z.ZodString;
+      id: z.ZodString;
+      locator: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>;
+  }, z.core.$strip>, z.ZodObject<{
+    type: z.ZodLiteral<"raw">;
+    title: z.ZodString;
+    json: z.ZodType<_$_makaio_contracts0.JsonValue, unknown, z.core.$ZodTypeInternals<_$_makaio_contracts0.JsonValue, unknown>>;
+  }, z.core.$strip>, z.ZodObject<{
+    type: z.ZodLiteral<"code">;
+    title: z.ZodString;
+    language: z.ZodString;
+    content: z.ZodString;
+  }, z.core.$strip>, z.ZodObject<{
+    type: z.ZodLiteral<"diagram">;
+    title: z.ZodString;
+    notation: z.ZodLiteral<"mermaid">;
+    source: z.ZodString;
+  }, z.core.$strip>], "type">>;
+}, z.core.$strip>;
+/** Provider-neutral artifact view model. */
+type ArtifactViewModel$1 = z.infer<typeof ArtifactViewModelSchema$1>;
+//#endregion
+//#region core/contracts/src/materialization/view-builder.d.ts
+/**
+ * Empty interface intended for declaration merging.
+ *
+ * Extension or product code augments this interface to register provider- or
+ * kind-specific view parameter shapes:
+ *
+ * ```ts
+ * declare module '@makaio/framework/contracts' {
+ *   interface ArtifactViewParamsMap {
+ *     'my-kind': { depth: number; includeArchived: boolean };
+ *   }
+ * }
+ * ```
+ *
+ * A builder's literal `kind` selects its corresponding shape through
+ * {@link ArtifactViewParamsFor}. Unregistered kinds remain open so artifact
+ * kinds never need central registration before they can be rendered.
+ */
+interface ArtifactViewParamsMap {}
+/**
+ * Resolve the authoring params for an artifact kind.
+ *
+ * Registered literal kinds receive their declaration-merged shape only when
+ * it is object-shaped. Arrays and functions are not valid parameter objects,
+ * so invalid registrations resolve to `never`; every other string receives
+ * the same open JSON-object-shaped type used by the runtime request schema.
+ * @typeParam K - Artifact kind handled by the builder.
+ */
+type ArtifactViewParamsFor<K extends string> = K extends keyof ArtifactViewParamsMap ? ArtifactViewParamsMap[K] extends object ? ArtifactViewParamsMap[K] extends readonly unknown[] ? never : ArtifactViewParamsMap[K] extends ((...args: never[]) => unknown) ? never : ArtifactViewParamsMap[K] : never : Readonly<Record<string, unknown>>;
+/**
+ * Runtime artifact view params schema.
+ *
+ * Validates that params are JSON-safe objects. The runtime schema is always
+ * {@link JsonObjectContractSchema}: requests cross process boundaries and must
+ * accept arbitrary artifact kinds without depending on declaration merging.
+ */
+declare const ArtifactViewParamsSchema: z.ZodType<Record<string, unknown>, Record<string, unknown>, z.core.$ZodTypeInternals<Record<string, unknown>, Record<string, unknown>>>;
+/**
+ * A request for an artifact view at a specific detail level.
+ *
+ * The same schema is used by surface bindings, resolver requests, and builder
+ * context — no parallel parameter types.
+ * @param level - Requested detail level (`link`, `summary`, or `full`).
+ * @param params - Optional JSON-safe runtime parameters.
+ */
+declare const ArtifactViewRequestSchema: z.ZodObject<{
+  level: z.ZodEnum<{
+    link: "link";
+    full: "full";
+    summary: "summary";
+  }>;
+  params: z.ZodOptional<z.ZodType<Record<string, unknown>, Record<string, unknown>, z.core.$ZodTypeInternals<Record<string, unknown>, Record<string, unknown>>>>;
+}, z.core.$strip>;
+/** A request for an artifact view at a specific detail level. */
+type ArtifactViewRequest = z.infer<typeof ArtifactViewRequestSchema>;
+/**
+ * Affordance declaration for artifact view rendering.
+ *
+ * Affordances are exact and authoritative when present. Each variant declares
+ * where and how an artifact kind may be rendered:
+ *
+ * - `'own-view'` — the artifact has its own full view (always at `full` level).
+ * - `'inline'` — the artifact may be inlined within a host artifact's view,
+ *   keyed by the host relation type. The optional `as` field is declaration
+ *   policy controlling the inline level; callers never supply it.
+ * - `'entry'` — the artifact may appear as an entry in a container (dashboard,
+ *   collection). Exactly one of `via` or `collection` must be present. The
+ *   optional `title` is declaration policy. The container caller selects
+ *   `request.level`; there is no separate entry-level property.
+ *
+ * Multiple entry declarations are legal.
+ */
+declare const ArtifactViewAffordanceDeclarationSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
+  kind: z.ZodLiteral<"own-view">;
+}, z.core.$strip>, z.ZodObject<{
+  kind: z.ZodLiteral<"inline">;
+  hostRelation: z.ZodString;
+  as: z.ZodOptional<z.ZodEnum<{
+    link: "link";
+    full: "full";
+    summary: "summary";
+  }>>;
+}, z.core.$strip>, z.ZodObject<{
+  kind: z.ZodLiteral<"entry">;
+  via: z.ZodOptional<z.ZodString>;
+  collection: z.ZodOptional<z.ZodString>;
+  title: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>], "kind">;
+/** Affordance declaration for artifact view rendering. */
+type ArtifactViewAffordanceDeclaration = z.infer<typeof ArtifactViewAffordanceDeclarationSchema>;
+/**
+ * Structural selector for requesting an artifact view through an affordance.
+ *
+ * Requests use only structural selectors — declaration-policy fields (`as`,
+ * `title`) are stripped. The container caller selects the detail level via
+ * the resolve request's top-level `level`, not on the affordance itself.
+ *
+ * - `'own-view'` — request the artifact's own full view.
+ * - `'inline'` + `hostRelation` — request an inline view keyed by relation.
+ * - `'entry'` + (`via` | `collection`) — request an entry view.
+ */
+declare const ArtifactViewAffordanceRequestSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
+  kind: z.ZodLiteral<"own-view">;
+}, z.core.$strip>, z.ZodObject<{
+  kind: z.ZodLiteral<"inline">;
+  hostRelation: z.ZodString;
+}, z.core.$strip>, z.ZodObject<{
+  kind: z.ZodLiteral<"entry">;
+  via: z.ZodOptional<z.ZodString>;
+  collection: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>], "kind">;
+/** Structural selector for requesting an artifact view through an affordance. */
+type ArtifactViewAffordanceRequest$1 = z.infer<typeof ArtifactViewAffordanceRequestSchema>;
+/**
+ * Context supplied to an {@link ArtifactViewBuilder}'s `build` method.
+ *
+ * Contains the resolved artifact, the requested view parameters, the
+ * deterministic generic sections produced by the framework, and the
+ * direct relations already present on the artifact. The context is
+ * readonly — builders compose their output from it without side effects.
+ *
+ * Deliberately excludes provider IDs, raw storage handles, `find`
+ * helpers, and bus transport concerns. Builders operate on fully
+ * resolved snapshots.
+ */
+interface ArtifactViewBuilderContext<K extends string = string> {
+  /** The fully resolved artifact revision. */
+  readonly artifact: ArtifactRevision$1;
+  /** Requested view detail level. */
+  readonly level: ArtifactViewLevel$1;
+  /** Structural affordance selector for the view. */
+  readonly affordance: ArtifactViewAffordanceRequest$1;
+  /** Optional JSON-safe runtime parameters. */
+  readonly params: ArtifactViewParamsFor<K> | undefined;
+  /**
+   * Deterministic generic sections produced by the framework's generic
+   * builder for this artifact, level, and kind registration.
+   *
+   * Builders may compose from these sections when they want to augment
+   * rather than fully replace the generic projection.
+   */
+  readonly genericSections: readonly ArtifactViewSection[];
+  /** Direct relations already present on the artifact revision. */
+  readonly relations: readonly ArtifactRelation[];
+  /**
+   * The context graph resolved from the kind registration's declared
+   * `defaultContext` selector via `ArtifactSubjects.resolveContext`.
+   *
+   * Present only when the kind registration declares a `defaultContext`
+   * selector AND context resolution succeeded (the resolve-context RPC
+   * was handled). `undefined` when the registration declares no selector
+   * or no resolver handled the request.
+   */
+  readonly defaultContext: ResolvedArtifactContextWire$1 | undefined;
+}
+/**
+ * Builder output for a single artifact view.
+ *
+ * Exactly three outcomes:
+ * - `undefined` — keep the generic sections unchanged.
+ * - `{ sections }` — completely replace the generic sections with the
+ *   supplied array. Builders that want to augment generic sections
+ *   compose explicitly from `context.genericSections`.
+ * - `{ render: false }` — suppress rendering entirely. The resolver
+ *   produces a `not-rendered` result.
+ */
+type ArtifactViewBuilderResult = undefined | {
+  readonly sections: readonly ArtifactViewSection[];
+} | {
+  readonly render: false;
+};
+/**
+ * Live artifact view builder registration.
+ *
+ * Builders match an exact `kind + schemaVersion` pair and carry a
+ * positive monotonic version. Only one active builder per key is
+ * allowed; collisions across owners are hard errors.
+ *
+ * Builder functions are live extension contributions and must not cross
+ * the bus. Only serializable requests and responses travel over the bus;
+ * the builder registry is an in-process construct.
+ */
+interface ArtifactViewBuilder<K extends string = string> {
+  /** Exact artifact kind this builder handles. */
+  readonly kind: K;
+  /** Exact schema version this builder handles. */
+  readonly schemaVersion: string;
+  /**
+   * Positive monotonic version of this builder.
+   *
+   * Used by the resolve protocol's `builderVersion` field. Must be a
+   * positive integer.
+   */
+  readonly version: number;
+  /**
+   * Build an artifact view for the given context.
+   * @param context - Fully resolved builder context.
+   * @returns Builder result, or a promise that resolves to one.
+   */
+  build(context: ArtifactViewBuilderContext<K>): Promise<ArtifactViewBuilderResult>;
+}
+/**
+ * Define a live artifact view builder while preserving its literal kind for
+ * declaration-merged {@link ArtifactViewParamsFor} inference.
+ *
+ * Contributions erase builders to `ArtifactViewBuilder<string>` when they
+ * enter the runtime registry. Define builders first so their `build` context
+ * remains correlated with the literal `kind` at the authoring boundary.
+ * @typeParam K - Literal artifact kind handled by the builder.
+ * @param builder - Builder registration with a literal artifact kind.
+ * @returns The same builder with its kind-specific context retained.
+ */
+declare function defineArtifactViewBuilder<const K extends string>(builder: ArtifactViewBuilder<K>): ArtifactViewBuilder<K>;
+/**
+ * Executable artifact view builders contribution declared by an
+ * extension package.
+ *
+ * The `createBuilders` factory is called during extension activation and
+ * must return the set of builder registrations to install. Returning a
+ * `Promise` allows async resource acquisition (e.g. lazy loading).
+ */
+interface ExtensionArtifactViewBuildersContribution {
+  /**
+   * Factory that produces the builder registrations for this extension.
+   *
+   * Called once during extension activation. The returned builders are
+   * registered with the artifact view builder registry under the
+   * extension's owner key, replacing any previous set.
+   * @returns Builder registrations or a promise resolving to them.
+   */
+  readonly createBuilders: () => readonly ArtifactViewBuilder[] | Promise<readonly ArtifactViewBuilder[]>;
+}
+//#endregion
+export { ArtifactViewRawSectionSchema as A, defineSurfaceBinding as B, ArtifactViewLink as C, ArtifactViewPropertiesSection as D, ArtifactViewModelSchema$1 as E, ArtifactViewSummarySection as F, ArtifactViewSummarySectionSchema as I, ArtifactViewTableSection as L, ArtifactViewRelationsSectionSchema as M, ArtifactViewSection as N, ArtifactViewPropertiesSectionSchema as O, ArtifactViewSectionSchema as P, ArtifactViewTableSectionSchema as R, ArtifactViewLevelSchema as S, ArtifactViewModel$1 as T, ArtifactViewDiagramSection as _, ArtifactViewBuilder as a, ArtifactViewEvidenceSectionSchema as b, ArtifactViewParamsFor as c, ArtifactViewRequest as d, ArtifactViewRequestSchema as f, ArtifactViewCodeSectionSchema as g, ArtifactViewCodeSection as h, ArtifactViewAffordanceRequestSchema as i, ArtifactViewRelationsSection as j, ArtifactViewRawSection as k, ArtifactViewParamsMap as l, defineArtifactViewBuilder as m, ArtifactViewAffordanceDeclarationSchema as n, ArtifactViewBuilderContext as o, ExtensionArtifactViewBuildersContribution as p, ArtifactViewAffordanceRequest$1 as r, ArtifactViewBuilderResult as s, ArtifactViewAffordanceDeclaration as t, ArtifactViewParamsSchema as u, ArtifactViewDiagramSectionSchema as v, ArtifactViewLinkSchema as w, ArtifactViewLevel$1 as x, ArtifactViewEvidenceSection as y, SurfaceBindingDefinition as z };