Assembly order, dependency snapshots, and request budget overrides

The policy implementation follows.

export function defineContextFragments<Input>(
  definitions: readonly ContextFragmentConfig<Input>[],
  options: ContextBuilderOptions<Input> = {},
): ContextBuilder<Input> {
  const ids = new Set<string>();
  const factories = definitions.map((definition) => {
    const metadata = {
      id: definition.id,
      sourceId: definition.sourceId,
      trust: definition.trust,
      lifetime: definition.lifetime,
      maxChars: definition.maxChars,
      role: definition.role,
    };
    breakWhile(
      typeof definition.format !== 'function',
      `Missing context formatter: ${metadata.id}`,
    );
    const format = definition.format.bind(definition);
    breakWhile(ids.has(metadata.id), `Duplicate context fragment: ${metadata.id}`);
    ids.add(metadata.id);
    return (input: Input): ContextFragment[] => [
      { ...metadata, value: synchronous(format(input), 'Context formatters must be synchronous') },
    ];
  });
  return contextBuilder(factories, options);
}

export function defineContextAssembly<
  Input,
  Id extends string = string,
  Placement extends string = string,
>(
  definitions: readonly ContextProjection<Input, Id, Placement>[],
  options: ContextAssemblyOptions<Input, Id, Placement>,
): ContextBuilder<Input> {
  const fragment = options.fragment.bind(options);
  const ids = new Set<string>();
  const factories = definitions.map((definition) => {
    // Contribution placements live in the same ID namespace, prefixed so they cannot collide with
    // a real fragment ID.
    const id =
      definition.kind === 'fragment' ? definition.id : `contributions:${definition.placement}`;
    breakWhile(ids.has(id), `Duplicate context projection: ${id}`);
    ids.add(id);
    if (definition.kind === 'fragment') {
      const id = definition.id;
      breakWhile(typeof definition.format !== 'function', `Missing context formatter: ${id}`);
      const format = definition.format.bind(definition);
      return (input: Input) => [
        synchronous(
          fragment(id, synchronous(format(input), 'Context formatters must be synchronous')),
          'Context fragment factories must be synchronous',
        ),
      ];
    }
    const create = options.contributions?.[definition.placement];
    breakWhile(
      typeof create !== 'function',
      `Unknown context contribution: ${definition.placement}`,
    );
    const expand = create!.bind(options.contributions);
    return (input: Input) =>
      synchronous(expand(input), 'Context contributions must be synchronous');
  });
  return contextBuilder(factories, options);
}