@rippling/rippling-sdk 0.2.0-alpha.108 → 0.2.0-alpha.110

package/src/lib/charts/schema.ts

@@ -1,72 +1,238 @@
-import { CHART_RULE_CONTRACT_VERSION } from './types';
+import {
+  type BaseIssue,
+  boolean,
+  type GenericSchema,
+  finite,
+  literal,
+  null_,
+  number,
+  picklist,
+  pipe,
+  safeParse,
+  strictObject,
+  string,
+  summarize,
+  union,
+  variant,
+} from 'valibot';
 
-/** Stable identifier for the published contract, versioned by the tag. */
+import { MalformedRuleError, UnknownNodeError } from './errors';
+import { CHART_RULE_CONTRACT_VERSION, type ParsedRule, type Rule, type RuleNode, type Scalar } from './types';
+import {
+  EQUALITY_COMPARISON_KINDS,
+  NUMERIC_COMPARISON_KINDS,
+  RULE_CHANNELS,
+  RULE_NODE_KINDS,
+} from './vocabulary';
+
+const ruleNodeKinds: ReadonlySet<string> = new Set(RULE_NODE_KINDS);
+const placeholderKeys: ReadonlySet<string> = new Set(['$rule', 'channel']);
+const ruleFieldKeys = ['$rule', 'channel', 'kind', 'value', 'left', 'right', 'cond', 'then', 'else'] as const;
+const scalarSchema: GenericSchema<unknown, Scalar> = union([
+  pipe(number(), finite()),
+  string(),
+  boolean(),
+  null_(),
+]);
+
+const parsedRules = new WeakSet<object>();
+
+/** @deprecated Use `CHART_RULE_CONTRACT_VERSION` to identify the executable contract. */
 export const CHART_RULE_SCHEMA_ID = `https://rippling.com/schemas/${CHART_RULE_CONTRACT_VERSION}.json`;
 
+function hasOwn(value: object, key: PropertyKey): boolean {
+  return Object.prototype.hasOwnProperty.call(value, key);
+}
+
+const refNodeSchema = strictObject({ kind: literal('value') });
+const literalNodeSchema = strictObject({ kind: literal('literal'), value: scalarSchema });
+const numericLiteralNodeSchema = strictObject({
+  kind: literal('literal'),
+  value: pipe(number(), finite()),
+});
+const requiredColorLiteralNodeSchema = strictObject({
+  kind: literal('literal'),
+  value: string(),
+});
+const optionalColorLiteralNodeSchema = strictObject({
+  kind: literal('literal'),
+  value: union([string(), null_()]),
+});
+const comparisonOperandSchema = variant('kind', [refNodeSchema, literalNodeSchema]);
+const numericOperandSchema = variant('kind', [refNodeSchema, numericLiteralNodeSchema]);
+
+const equalityComparisonNodeSchema = strictObject({
+  kind: picklist(EQUALITY_COMPARISON_KINDS),
+  left: comparisonOperandSchema,
+  right: comparisonOperandSchema,
+});
+
+const numericComparisonNodeSchema = strictObject({
+  kind: picklist(NUMERIC_COMPARISON_KINDS),
+  left: numericOperandSchema,
+  right: numericOperandSchema,
+});
+
+const comparisonNodeSchema = variant('kind', [equalityComparisonNodeSchema, numericComparisonNodeSchema]);
+
+const ifElseNodeSchema = strictObject({
+  kind: literal('ifElse'),
+  cond: comparisonNodeSchema,
+  then: requiredColorLiteralNodeSchema,
+  else: optionalColorLiteralNodeSchema,
+});
+
 /**
- * JSON Schema (2020-12) for the `{$rule}` placeholder and its closed node set.
+ * Executable runtime schema for a chart-rule node.
  *
- * This is the contract. A consumer that keeps its own rule evaluator (rather
- * than importing `evaluate`) can validate against this so the two never drift —
- * every kind and operand shape the builders can emit is described here.
+ * v1 is intentionally non-recursive. A comparison contains only `value` or
+ * literal operands, and a conditional contains one comparison plus two colour
+ * literals. Contract tests prove that every public builder output parses.
+ */
+const ruleNodeSchema: GenericSchema<unknown, RuleNode, BaseIssue<unknown>> = variant('kind', [
+  refNodeSchema,
+  literalNodeSchema,
+  equalityComparisonNodeSchema,
+  numericComparisonNodeSchema,
+  ifElseNodeSchema,
+]);
+
+/** Runtime schema for the `{$rule, channel}` value embedded in a chart option. */
+const rulePlaceholderSchema = strictObject({
+  $rule: ifElseNodeSchema,
+  channel: picklist(RULE_CHANNELS),
+});
+
+/**
+ * Runtime schema for either a bare rule node or a chart-option placeholder.
+ * Persisted and agent-authored JSON crosses this boundary as `unknown`.
+ */
+export const chartRuleSchema: GenericSchema<unknown, Rule, BaseIssue<unknown>> = union([
+  rulePlaceholderSchema,
+  ruleNodeSchema,
+]);
+
+/** Parse untrusted chart-rule JSON and return an immutable validated clone. */
+export function parseChartRule(input: unknown): ParsedRule {
+  if (isParsedRule(input)) {
+    return input;
+  }
+  preflight(input);
+  const result = safeParse(chartRuleSchema, input);
+  if (result.success) {
+    return markParsedRule(result.output);
+  }
+  throw new MalformedRuleError(summarize(result.issues));
+}
+
+/**
+ * Valibot's object schemas use `key in input`, which also reads inherited
+ * properties. Reject inherited rule fields before parsing so prototype data
+ * cannot supply required operands or bypass the flat v1 contract.
  */
-export const chartRuleSchema = {
-  $schema: 'https://json-schema.org/draft/2020-12/schema',
-  $id: CHART_RULE_SCHEMA_ID,
-  title: 'Chart rule placeholder',
-  description: 'A rule tree the chart agent emits into a chart option, marked with $rule.',
-  type: 'object',
-  required: ['$rule', 'channel'],
-  additionalProperties: false,
-  properties: {
-    // A colour rule's top-level tree is the conditional-value form (`when(...)`),
-    // matching what `color()` builds and accepts. A bare ref/comparison/literal
-    // resolves to a number/boolean/constant, not a colour decision.
-    $rule: { $ref: '#/$defs/ifElse' },
-    channel: { const: 'color' },
-  },
-  $defs: {
-    scalar: { type: ['number', 'string', 'boolean', 'null'] },
-    node: {
-      oneOf: [
-        { $ref: '#/$defs/ref' },
-        { $ref: '#/$defs/literal' },
-        { $ref: '#/$defs/comparison' },
-        { $ref: '#/$defs/ifElse' },
-      ],
-    },
-    ref: {
-      type: 'object',
-      required: ['kind'],
-      additionalProperties: false,
-      properties: { kind: { const: 'value' } },
-    },
-    literal: {
-      type: 'object',
-      required: ['kind', 'value'],
-      additionalProperties: false,
-      properties: { kind: { const: 'literal' }, value: { $ref: '#/$defs/scalar' } },
-    },
-    comparison: {
-      type: 'object',
-      required: ['kind', 'left', 'right'],
-      additionalProperties: false,
-      properties: {
-        kind: { enum: ['equals', 'isNot', 'lessThan', 'greaterThan', 'lessOrEqual', 'greaterOrEqual'] },
-        left: { $ref: '#/$defs/node' },
-        right: { $ref: '#/$defs/node' },
-      },
-    },
-    ifElse: {
-      type: 'object',
-      required: ['kind', 'cond', 'then', 'else'],
-      additionalProperties: false,
-      properties: {
-        kind: { const: 'ifElse' },
-        cond: { $ref: '#/$defs/node' },
-        then: { $ref: '#/$defs/node' },
-        else: { $ref: '#/$defs/node' },
-      },
-    },
-  },
-} as const;
+function preflight(input: unknown): void {
+  assertNoInheritedRuleFields(input);
+  const root = unwrapPlaceholder(input);
+  assertNoInheritedRuleFields(root);
+  assertKnownNode(root);
+
+  if (!isRecord(root) || !hasOwn(root, 'kind')) {
+    return;
+  }
+  if (root['kind'] === 'ifElse') {
+    inspectChildren(root, ['cond', 'then', 'else']);
+    const condition = root['cond'];
+    inspectComparison(condition);
+  } else if (typeof root['kind'] === 'string' && isComparisonKind(root['kind'])) {
+    inspectComparison(root);
+  }
+}
+
+function inspectComparison(value: unknown): void {
+  assertNoInheritedRuleFields(value);
+  assertKnownNode(value);
+  if (isRecord(value)) {
+    inspectChildren(value, ['left', 'right']);
+  }
+}
+
+function inspectChildren(parent: Record<string, unknown>, keys: readonly string[]): void {
+  for (const key of keys) {
+    if (hasOwn(parent, key)) {
+      const child = parent[key];
+      assertNoInheritedRuleFields(child);
+      assertKnownNode(child);
+    }
+  }
+}
+
+function assertNoInheritedRuleFields(value: unknown): void {
+  if (!isRecord(value)) {
+    return;
+  }
+  for (const key of ruleFieldKeys) {
+    if (key in value && !hasOwn(value, key)) {
+      throw new MalformedRuleError(`a chart rule must not inherit the ${key} property`);
+    }
+  }
+}
+
+function assertKnownNode(value: unknown): void {
+  if (
+    isRecord(value) &&
+    hasOwn(value, 'kind') &&
+    typeof value['kind'] === 'string' &&
+    !ruleNodeKinds.has(value['kind'])
+  ) {
+    throw new UnknownNodeError(value['kind']);
+  }
+}
+
+function isComparisonKind(kind: string): boolean {
+  return kind !== 'literal' && kind !== 'value' && kind !== 'ifElse' && ruleNodeKinds.has(kind);
+}
+
+function isRecord(value: unknown): value is Record<string, unknown> {
+  return value !== null && typeof value === 'object' && !Array.isArray(value);
+}
+
+function unwrapPlaceholder(input: unknown): unknown {
+  if (input === null || typeof input !== 'object' || Array.isArray(input) || !hasOwn(input, '$rule')) {
+    return input;
+  }
+  const unexpectedKey = Object.keys(input).find((key) => !placeholderKeys.has(key));
+  if (unexpectedKey !== undefined) {
+    throw new MalformedRuleError(`a rule placeholder has an unexpected property: ${unexpectedKey}`);
+  }
+  return (input as { $rule?: unknown }).$rule;
+}
+
+function isParsedRule(input: unknown): input is ParsedRule {
+  return input !== null && typeof input === 'object' && !Array.isArray(input) && parsedRules.has(input);
+}
+
+/**
+ * Mark the validated clone so `evaluate(parseChartRule(input), ctx)` does not
+ * reparse the full value for every datum. Freezing prevents a caller from
+ * mutating a trusted value after validation.
+ */
+function markParsedRule(rule: Rule): ParsedRule {
+  const stack: object[] = [rule];
+  const seen = new WeakSet<object>();
+  while (stack.length > 0) {
+    const current = stack.pop();
+    if (!current || seen.has(current)) {
+      continue;
+    }
+    seen.add(current);
+    for (const value of Object.values(current)) {
+      if (value !== null && typeof value === 'object') {
+        stack.push(value);
+      }
+    }
+    Object.freeze(current);
+  }
+
+  parsedRules.add(rule);
+  return rule as ParsedRule;
+}

package/src/lib/charts/types.ts

@@ -1,18 +1,22 @@
 /**
  * Chart rule vocabulary — shared types.
  *
- * A rule is a small, serializable tree of nodes discriminated by `kind`. The
+ * A rule is a small, serializable value discriminated by `kind`. The
  * agent builds it with the helpers in `builders.ts`, which emit it wrapped in a
  * `{$rule}` placeholder — the same idea as the `{$fn}` placeholders a chart
  * already emits. The renderer resolves it with `evaluate`; the settings panel
  * reads it with `describe`. All three agree because a node can only ever be one
- * of the kinds defined here — the closed set the `chartRuleSchema` describes.
+ * of the kinds defined here — the closed set the executable `chartRuleSchema`
+ * validates at runtime.
  *
- * v1 is scoped to conditional formatting: compare this datum's `value` against a
- * constant, and (optionally) pick between two values. Richer pieces — aggregates,
- * logic, more refs — are the documented roadmap in the README.
+ * v1 is deliberately non-recursive: compare this datum's `value` or a literal
+ * against another literal, then choose between two colour literals. Rules may
+ * not appear inside operands or branches. Richer expressions require a future
+ * contract version.
  */
 
+import { COMPARISON_KINDS, RULE_CHANNELS } from './vocabulary';
+
 export const CHART_RULE_CONTRACT_VERSION = 'chart_rule.v1' as const;
 export type ChartRuleContractVersion = typeof CHART_RULE_CONTRACT_VERSION;
 
@@ -26,33 +30,39 @@ export type Scalar = number | string | boolean | null;
 /** Reads a value out of the evaluation context — this datum's plotted value. */
 export type RefNode = { kind: 'value' };
 
-export interface LiteralNode {
+export interface LiteralNode<TValue extends Scalar = Scalar> {
   kind: 'literal';
-  value: Scalar;
+  value: TValue;
 }
 
-export type ComparisonKind =
-  | 'equals'
-  | 'isNot'
-  | 'lessThan'
-  | 'greaterThan'
-  | 'lessOrEqual'
-  | 'greaterOrEqual';
-export interface ComparisonNode {
-  kind: ComparisonKind;
-  left: RuleNode;
-  right: RuleNode;
+export type ComparisonOperandNode = RefNode | LiteralNode;
+export type NumericOperandNode = RefNode | LiteralNode<number>;
+
+export type ComparisonKind = (typeof COMPARISON_KINDS)[number];
+export interface EqualityComparisonNode {
+  kind: 'equals' | 'isNot';
+  left: ComparisonOperandNode;
+  right: ComparisonOperandNode;
 }
+export interface NumericComparisonNode {
+  kind: Exclude<ComparisonKind, EqualityComparisonNode['kind']>;
+  left: NumericOperandNode;
+  right: NumericOperandNode;
+}
+export type ComparisonNode = EqualityComparisonNode | NumericComparisonNode;
+
+/** A node whose evaluated result is valid as a `when(...)` condition in v1. */
+export type ConditionNode = ComparisonNode;
 
 /** The conditional-value form produced by `when(cond, then, else)`. */
 export interface IfElseNode {
   kind: 'ifElse';
-  cond: RuleNode;
-  then: RuleNode;
-  else: RuleNode;
+  cond: ConditionNode;
+  then: LiteralNode<string>;
+  else: LiteralNode<string | null>;
 }
 
-/** Any node of a rule tree. */
+/** Any top-level node accepted by the v1 runtime boundary. */
 export type RuleNode = RefNode | LiteralNode | ComparisonNode | IfElseNode;
 
 /* -------------------------------------------------------------------------- */
@@ -64,21 +74,26 @@ export type RuleNode = RefNode | LiteralNode | ComparisonNode | IfElseNode;
  * colour of a series/datum. Other channels (opacity, label visibility, …) are
  * the documented roadmap and would be added here.
  */
-export type RuleChannel = 'color';
+export type RuleChannel = (typeof RULE_CHANNELS)[number];
 
 /**
- * What a builder returns: a rule tree, marked so the renderer can find it, and
+ * What a builder returns: a flat rule value, marked so the renderer can find it, and
  * tagged with the channel it targets. `channel: 'color'` says this resolves to a
  * colour — so a reader sees the target without inferring it from where it sits.
  */
 export interface RulePlaceholder {
-  $rule: RuleNode;
+  $rule: IfElseNode;
   channel: RuleChannel;
 }
 
-/** A placeholder, or the bare tree — what `evaluate` and `describe` accept. */
+/** A placeholder, or a bare node — what `evaluate` and `describe` accept. */
 export type Rule = RulePlaceholder | RuleNode;
 
+type DeepReadonly<T> = T extends object ? { readonly [Key in keyof T]: DeepReadonly<T[Key]> } : T;
+
+/** The deeply frozen value returned by `parseChartRule`. */
+export type ParsedRule = DeepReadonly<Rule>;
+
 /* -------------------------------------------------------------------------- */
 /* Evaluation                                                                   */
 /* -------------------------------------------------------------------------- */
@@ -91,11 +106,7 @@ export interface RuleContext {
 /** The result of evaluating a node. */
 export type RuleValue = Scalar;
 
-/**
- * The deepest a rule may nest before `evaluate`/`describe` refuse it. Real rules
- * are a handful of levels; this only stops a pathological deserialized tree from
- * overflowing the stack. Far below the JS call-stack limit.
- */
+/** @deprecated v1 is non-recursive. Retained for source compatibility. */
 export const MAX_RULE_DEPTH = 256;
 
 /* -------------------------------------------------------------------------- */

package/src/lib/charts/visualization-grammar.ts

@@ -0,0 +1,67 @@
+import { RULE_CHANNELS, RULE_NODE_KINDS } from './vocabulary';
+
+/**
+ * Machine-readable authoring surface for chart visualization primitives.
+ *
+ * The SDK build serializes this registry to `capabilities.json`. Keep the
+ * registry aligned with the public builders and the serialized-node schema;
+ * contract tests enforce both relationships.
+ */
+export const visualizationGrammarCapabilities = {
+  contractVersion: 1,
+  moduleSpecifier: 'npm:@rippling/rippling-sdk/lib/charts',
+  builders: {
+    value: {
+      kind: 'input',
+      returns: 'number',
+    },
+    literal: {
+      kind: 'literal',
+      parameters: ['scalar'],
+      returns: 'value',
+    },
+    equals: {
+      kind: 'comparison',
+      parameters: ['value', 'value'],
+      returns: 'condition',
+    },
+    isNot: {
+      kind: 'comparison',
+      parameters: ['value', 'value'],
+      returns: 'condition',
+    },
+    lessThan: {
+      kind: 'comparison',
+      parameters: ['value', 'value'],
+      returns: 'condition',
+    },
+    greaterThan: {
+      kind: 'comparison',
+      parameters: ['value', 'value'],
+      returns: 'condition',
+    },
+    lessOrEqual: {
+      kind: 'comparison',
+      parameters: ['value', 'value'],
+      returns: 'condition',
+    },
+    greaterOrEqual: {
+      kind: 'comparison',
+      parameters: ['value', 'value'],
+      returns: 'condition',
+    },
+    when: {
+      kind: 'conditional',
+      parameters: ['condition', 'color', 'color?'],
+      returns: 'conditional-color',
+    },
+    color: {
+      kind: 'channel',
+      parameters: ['conditional-color'],
+      returns: 'color-rule',
+      placeholderChannel: 'color',
+    },
+  },
+  supportedChannels: RULE_CHANNELS,
+  supportedNodeKinds: RULE_NODE_KINDS,
+} as const;

package/src/lib/charts/vocabulary.ts

@@ -0,0 +1,7 @@
+/** Runtime constants shared by the schema, capability manifest, and types. */
+export const EQUALITY_COMPARISON_KINDS = ['equals', 'isNot'] as const;
+export const NUMERIC_COMPARISON_KINDS = ['lessThan', 'greaterThan', 'lessOrEqual', 'greaterOrEqual'] as const;
+export const COMPARISON_KINDS = [...EQUALITY_COMPARISON_KINDS, ...NUMERIC_COMPARISON_KINDS] as const;
+
+export const RULE_NODE_KINDS = ['literal', 'value', ...COMPARISON_KINDS, 'ifElse'] as const;
+export const RULE_CHANNELS = ['color'] as const;

package/src/lib/charts.ts

@@ -10,11 +10,12 @@ export {
   literal,
   value,
   when,
+  type NumericOperand,
   type Operand,
 } from './charts/builders';
 export { evaluate } from './charts/evaluate';
 export { describe } from './charts/describe';
-export { chartRuleSchema, CHART_RULE_SCHEMA_ID } from './charts/schema';
+export { chartRuleSchema, CHART_RULE_SCHEMA_ID, parseChartRule } from './charts/schema';
 export {
   ChartRuleError,
   MalformedRuleError,
@@ -28,10 +29,16 @@ export {
   type ChartRuleContractVersion,
   type ComparisonKind,
   type ComparisonNode,
+  type ComparisonOperandNode,
+  type ConditionNode,
   type Control,
   type ControlRole,
+  type EqualityComparisonNode,
   type IfElseNode,
   type LiteralNode,
+  type NumericComparisonNode,
+  type NumericOperandNode,
+  type ParsedRule,
   type RefNode,
   type Rule,
   type RuleChannel,

package/src/lib/manifest/composition.ts

@@ -0,0 +1,133 @@
+import type { BuiltManifest } from './manifest-builder';
+import {
+  registeredComponent,
+  entryKey,
+  type CompileContext,
+  type MetadataEntry,
+} from './definitions/component';
+
+// Existing CLI loaders use this stable marker to request deferred source compilation.
+const manifestBuilds = Symbol.for('@rippling/sdk/package-sources');
+type DeferredBuild = { readonly index: number; readonly entry: MetadataEntry };
+
+/** Compose new definitions; legacy ManifestBuilder remains an independent authoring flow. */
+export type ManifestInput = object;
+
+export interface DefineManifestOptions {
+  components: readonly ManifestInput[];
+}
+
+export interface ManifestDefinition extends BuiltManifest {
+  readonly [manifestBuilds]?: readonly DeferredBuild[];
+}
+
+/** Run the build hooks supplied by component implementations, preserving the metadata JSON contract. */
+export async function compileManifest(
+  definition: Readonly<ManifestDefinition>,
+  bundle: (entrypoint: URL) => Promise<string>,
+): Promise<Readonly<ManifestDefinition>> {
+  const builds = definition[manifestBuilds] ?? [];
+  if (builds.length === 0) return definition;
+  const compiled: ManifestDefinition = JSON.parse(JSON.stringify({ ...definition }));
+  for (const { index, entry } of builds) {
+    const config = await entry.build!({ bundle });
+    compiled.components[index] = JSON.parse(JSON.stringify(config));
+  }
+  return freezeManifest(compiled);
+}
+
+function canonicalJson(value: unknown): string {
+  return JSON.stringify(value, (_key, item: unknown) =>
+    item != null && typeof item === 'object' && !Array.isArray(item) ?
+      Object.fromEntries(Object.entries(item).sort(([left], [right]) => left.localeCompare(right)))
+    : item,
+  );
+}
+
+/** Collect references, then compile batches. Component-specific behavior lives in definitions/. */
+export function defineManifest(options: DefineManifestOptions): Readonly<ManifestDefinition> {
+  const definitions: object[] = [];
+  const visited = new Set<object>();
+  const batches = new Map<
+    object,
+    {
+      implementation: NonNullable<ReturnType<typeof registeredComponent>>['implementation'];
+      definitions: object[];
+    }
+  >();
+  const entries: MetadataEntry[] = [];
+  const visit = (definition: object): void => {
+    if (visited.has(definition)) return;
+    visited.add(definition);
+    const registered = registeredComponent(definition);
+    if (registered != null) {
+      definitions.push(definition);
+      for (const dependency of registered.references()) visit(dependency);
+      const implementation = registered.implementation;
+      const batch = batches.get(implementation.batchKey) ?? { implementation, definitions: [] };
+      batch.definitions.push(definition);
+      batches.set(implementation.batchKey, batch);
+    } else {
+      throw new Error(
+        'Use defineX helpers in defineManifest; existing constructors belong in ManifestBuilder.',
+      );
+    }
+  };
+  options.components.forEach(visit);
+  const context: CompileContext = { definitions };
+  for (const batch of batches.values()) {
+    for (const output of batch.implementation.compileBatch(batch.definitions, context))
+      entries.push('type' in output ? { config: output } : output);
+  }
+
+  const snapshots: Record<string, any>[] = JSON.parse(JSON.stringify(entries.map((entry) => entry.config)));
+  const unique = new Map<string, { config: Record<string, any>; entry: MetadataEntry }>();
+  for (const [index, config] of snapshots.entries()) {
+    const entry = entries[index]!;
+    const key = entryKey(entry);
+    const existing = unique.get(key);
+    if (existing != null) {
+      for (const parent of ['model_name', 'model_rql_name', 'object_rql_name']) {
+        if (existing.config[parent] !== config[parent])
+          throw new Error(`Conflicting manifest component ${key}: apiName must be unique across objects.`);
+      }
+      if (entry.fallback && !existing.entry.fallback) continue;
+      if (!entry.fallback && existing.entry.fallback) {
+        unique.set(key, { config, entry });
+        continue;
+      }
+      if (canonicalJson(existing.config) !== canonicalJson(config))
+        throw new Error(`Conflicting manifest component ${key}`);
+      if (existing.entry.build != null && entry.build != null && existing.entry.buildKey !== entry.buildKey)
+        throw new Error(`Conflicting manifest source ${key}`);
+      if (entry.build == null && existing.entry.build != null) continue;
+    }
+    unique.set(key, { config, entry });
+  }
+  const builds = [...unique.values()].flatMap(({ entry }, index) =>
+    entry.build == null ? [] : [{ index, entry }],
+  );
+  const manifest: ManifestDefinition = {
+    metadata: {},
+    components: [...unique.values()].map(({ config }) => config),
+  };
+  if (builds.length > 0) {
+    Object.defineProperty(manifest, manifestBuilds, { value: Object.freeze(builds) });
+    Object.defineProperty(manifest, 'toJSON', {
+      value(): never {
+        throw new Error(
+          'Manifest source entrypoints must be compiled before JSON export. Use rippling project export or compileManifest.',
+        );
+      },
+    });
+  }
+  return freezeManifest(manifest);
+}
+
+function freezeManifest<T>(value: T): T {
+  if (value != null && typeof value === 'object') {
+    Object.values(value).forEach(freezeManifest);
+    Object.freeze(value);
+  }
+  return value;
+}