@prisma-next/framework-components 0.0.1

package/src/control-stack.ts

@@ -0,0 +1,292 @@
+import type { CodecLookup } from './codec-types';
+import type {
+  ControlAdapterDescriptor,
+  ControlDriverDescriptor,
+  ControlExtensionDescriptor,
+  ControlFamilyDescriptor,
+  ControlTargetDescriptor,
+} from './control-descriptors';
+import type {
+  AuthoringContributions,
+  AuthoringFieldNamespace,
+  AuthoringFieldPresetDescriptor,
+  AuthoringTypeConstructorDescriptor,
+  AuthoringTypeNamespace,
+} from './framework-authoring';
+import type { ComponentMetadata } from './framework-components';
+import type { TypesImportSpec } from './types-import-spec';
+
+export interface AssembledAuthoringContributions {
+  readonly field: AuthoringFieldNamespace;
+  readonly type: AuthoringTypeNamespace;
+}
+
+export interface ControlStack<
+  TFamilyId extends string = string,
+  TTargetId extends string = string,
+> {
+  readonly family: ControlFamilyDescriptor<TFamilyId>;
+  readonly target: ControlTargetDescriptor<TFamilyId, TTargetId>;
+  readonly adapter?: ControlAdapterDescriptor<TFamilyId, TTargetId> | undefined;
+  readonly driver?: ControlDriverDescriptor<TFamilyId, TTargetId> | undefined;
+  readonly extensionPacks: readonly ControlExtensionDescriptor<TFamilyId, TTargetId>[];
+
+  readonly codecTypeImports: ReadonlyArray<TypesImportSpec>;
+  readonly operationTypeImports: ReadonlyArray<TypesImportSpec>;
+  readonly queryOperationTypeImports: ReadonlyArray<TypesImportSpec>;
+  readonly extensionIds: ReadonlyArray<string>;
+  readonly codecLookup: CodecLookup;
+  readonly authoringContributions: AssembledAuthoringContributions;
+}
+
+export interface CreateControlStackInput<
+  TFamilyId extends string = string,
+  TTargetId extends string = string,
+> {
+  readonly family: ControlFamilyDescriptor<TFamilyId>;
+  readonly target: ControlTargetDescriptor<TFamilyId, TTargetId>;
+  readonly adapter?: ControlAdapterDescriptor<TFamilyId, TTargetId> | undefined;
+  readonly driver?: ControlDriverDescriptor<TFamilyId, TTargetId> | undefined;
+  readonly extensionPacks?:
+    | ReadonlyArray<ControlExtensionDescriptor<TFamilyId, TTargetId>>
+    | undefined;
+}
+
+function addUniqueId(ids: string[], seen: Set<string>, id: string): void {
+  if (!seen.has(id)) {
+    ids.push(id);
+    seen.add(id);
+  }
+}
+
+export function assertUniqueCodecOwner(options: {
+  readonly codecId: string;
+  readonly owners: Map<string, string>;
+  readonly descriptorId: string;
+  readonly entityLabel: string;
+  readonly entityOwnershipLabel: string;
+}): void {
+  const existingOwner = options.owners.get(options.codecId);
+  if (existingOwner !== undefined) {
+    throw new Error(
+      `Duplicate ${options.entityLabel} for codecId "${options.codecId}". ` +
+        `Descriptor "${options.descriptorId}" conflicts with "${existingOwner}". ` +
+        `Each codecId can only have one ${options.entityOwnershipLabel}.`,
+    );
+  }
+}
+
+export function extractCodecTypeImports(
+  descriptors: ReadonlyArray<Pick<ComponentMetadata, 'types'>>,
+): ReadonlyArray<TypesImportSpec> {
+  const imports: TypesImportSpec[] = [];
+
+  for (const descriptor of descriptors) {
+    const codecTypes = descriptor.types?.codecTypes;
+    if (codecTypes?.import) {
+      imports.push(codecTypes.import);
+    }
+    if (codecTypes?.typeImports) {
+      imports.push(...codecTypes.typeImports);
+    }
+  }
+
+  return imports;
+}
+
+export function extractOperationTypeImports(
+  descriptors: ReadonlyArray<Pick<ComponentMetadata, 'types'>>,
+): ReadonlyArray<TypesImportSpec> {
+  const imports: TypesImportSpec[] = [];
+
+  for (const descriptor of descriptors) {
+    const operationTypes = descriptor.types?.operationTypes;
+    if (operationTypes?.import) {
+      imports.push(operationTypes.import);
+    }
+  }
+
+  return imports;
+}
+
+export function extractQueryOperationTypeImports(
+  descriptors: ReadonlyArray<Pick<ComponentMetadata, 'types'>>,
+): ReadonlyArray<TypesImportSpec> {
+  const imports: TypesImportSpec[] = [];
+
+  for (const descriptor of descriptors) {
+    const queryOperationTypes = descriptor.types?.queryOperationTypes;
+    if (queryOperationTypes?.import) {
+      imports.push(queryOperationTypes.import);
+    }
+  }
+
+  return imports;
+}
+
+export function extractComponentIds(
+  family: { readonly id: string },
+  target: { readonly id: string },
+  adapter: { readonly id: string } | undefined,
+  extensions: ReadonlyArray<{ readonly id: string }>,
+): ReadonlyArray<string> {
+  const ids: string[] = [];
+  const seen = new Set<string>();
+
+  addUniqueId(ids, seen, family.id);
+  addUniqueId(ids, seen, target.id);
+  if (adapter) {
+    addUniqueId(ids, seen, adapter.id);
+  }
+
+  for (const ext of extensions) {
+    addUniqueId(ids, seen, ext.id);
+  }
+
+  return ids;
+}
+
+function isTypeConstructorDescriptor(value: unknown): value is AuthoringTypeConstructorDescriptor {
+  return (
+    typeof value === 'object' &&
+    value !== null &&
+    (value as { kind?: unknown }).kind === 'typeConstructor'
+  );
+}
+
+function isFieldPresetDescriptor(value: unknown): value is AuthoringFieldPresetDescriptor {
+  return (
+    typeof value === 'object' &&
+    value !== null &&
+    (value as { kind?: unknown }).kind === 'fieldPreset'
+  );
+}
+
+function mergeAuthoringNamespaces(
+  target: Record<string, unknown>,
+  source: Record<string, unknown>,
+  path: readonly string[],
+  leafGuard: (value: unknown) => boolean,
+  label: string,
+): void {
+  const assertSafePath = (currentPath: readonly string[]) => {
+    const blockedSegment = currentPath.find(
+      (segment) => segment === '__proto__' || segment === 'constructor' || segment === 'prototype',
+    );
+    if (blockedSegment) {
+      throw new Error(
+        `Invalid authoring ${label} helper "${currentPath.join('.')}". Helper path segments must not use "${blockedSegment}".`,
+      );
+    }
+  };
+
+  for (const [key, sourceValue] of Object.entries(source)) {
+    const currentPath = [...path, key];
+    assertSafePath(currentPath);
+    const hasExistingValue = Object.hasOwn(target, key);
+    const existingValue = hasExistingValue ? target[key] : undefined;
+
+    if (!hasExistingValue) {
+      target[key] = sourceValue;
+      continue;
+    }
+
+    const existingIsLeaf = leafGuard(existingValue);
+    const sourceIsLeaf = leafGuard(sourceValue);
+
+    if (existingIsLeaf || sourceIsLeaf) {
+      throw new Error(
+        `Duplicate authoring ${label} helper "${currentPath.join('.')}". Descriptor contributions must be unique across composed components.`,
+      );
+    }
+
+    mergeAuthoringNamespaces(
+      existingValue as Record<string, unknown>,
+      sourceValue as Record<string, unknown>,
+      currentPath,
+      leafGuard,
+      label,
+    );
+  }
+}
+
+export function assembleAuthoringContributions(
+  descriptors: ReadonlyArray<{ readonly authoring?: AuthoringContributions }>,
+): AssembledAuthoringContributions {
+  const field = {} as Record<string, unknown>;
+  const type = {} as Record<string, unknown>;
+
+  for (const descriptor of descriptors) {
+    if (descriptor.authoring?.field) {
+      mergeAuthoringNamespaces(
+        field,
+        descriptor.authoring.field,
+        [],
+        isFieldPresetDescriptor,
+        'field',
+      );
+    }
+    if (!descriptor.authoring?.type) {
+      continue;
+    }
+    mergeAuthoringNamespaces(
+      type,
+      descriptor.authoring.type,
+      [],
+      isTypeConstructorDescriptor,
+      'type',
+    );
+  }
+
+  return {
+    field: field as AuthoringFieldNamespace,
+    type: type as AuthoringTypeNamespace,
+  };
+}
+
+export function extractCodecLookup(
+  descriptors: ReadonlyArray<Pick<ComponentMetadata & { id?: string }, 'types' | 'id'>>,
+): CodecLookup {
+  const byId = new Map<string, import('./codec-types').Codec>();
+  const owners = new Map<string, string>();
+  for (const descriptor of descriptors) {
+    const codecInstances = descriptor.types?.codecTypes?.codecInstances;
+    if (!codecInstances) continue;
+    const descriptorId = descriptor.id ?? '<unknown>';
+    for (const codec of codecInstances) {
+      assertUniqueCodecOwner({
+        codecId: codec.id,
+        owners,
+        descriptorId,
+        entityLabel: 'codec instance',
+        entityOwnershipLabel: 'codec instance provider',
+      });
+      owners.set(codec.id, descriptorId);
+      byId.set(codec.id, codec);
+    }
+  }
+  return { get: (id) => byId.get(id) };
+}
+
+export function createControlStack<TFamilyId extends string, TTargetId extends string>(
+  input: CreateControlStackInput<TFamilyId, TTargetId>,
+): ControlStack<TFamilyId, TTargetId> {
+  const { family, target, adapter, driver, extensionPacks = [] } = input;
+
+  const allDescriptors = [family, target, ...(adapter ? [adapter] : []), ...extensionPacks];
+
+  return {
+    family,
+    target,
+    adapter,
+    driver,
+    extensionPacks: extensionPacks as readonly ControlExtensionDescriptor<TFamilyId, TTargetId>[],
+
+    codecTypeImports: extractCodecTypeImports(allDescriptors),
+    operationTypeImports: extractOperationTypeImports(allDescriptors),
+    queryOperationTypeImports: extractQueryOperationTypeImports(allDescriptors),
+    extensionIds: extractComponentIds(family, target, adapter, extensionPacks),
+    codecLookup: extractCodecLookup(allDescriptors),
+    authoringContributions: assembleAuthoringContributions(allDescriptors),
+  };
+}

package/src/emission-types.ts

@@ -0,0 +1,28 @@
+import type { Contract, ContractModel } from '@prisma-next/contract/types';
+import type { TypesImportSpec } from './types-import-spec';
+
+export interface GenerateContractTypesOptions {
+  readonly queryOperationTypeImports?: ReadonlyArray<TypesImportSpec>;
+}
+
+export interface ValidationContext {
+  readonly codecTypeImports?: ReadonlyArray<TypesImportSpec>;
+  readonly operationTypeImports?: ReadonlyArray<TypesImportSpec>;
+  readonly extensionIds?: ReadonlyArray<string>;
+}
+
+export interface EmissionSpi {
+  readonly id: string;
+
+  generateStorageType(contract: Contract, storageHashTypeName: string): string;
+
+  generateModelStorageType(modelName: string, model: ContractModel): string;
+
+  getFamilyImports(): string[];
+
+  getFamilyTypeAliases(options?: GenerateContractTypesOptions): string;
+
+  getTypeMapsExpression(): string;
+
+  getContractWrapper(contractBaseName: string, typeMapsName: string): string;
+}

package/src/execution-descriptors.ts

@@ -0,0 +1,71 @@
+import type {
+  RuntimeAdapterInstance,
+  RuntimeDriverInstance,
+  RuntimeExtensionInstance,
+  RuntimeFamilyInstance,
+  RuntimeTargetInstance,
+} from './execution-instances';
+import type {
+  AdapterDescriptor,
+  DriverDescriptor,
+  ExtensionDescriptor,
+  FamilyDescriptor,
+  TargetDescriptor,
+} from './framework-components';
+
+export interface RuntimeFamilyDescriptor<
+  TFamilyId extends string,
+  TFamilyInstance extends RuntimeFamilyInstance<TFamilyId> = RuntimeFamilyInstance<TFamilyId>,
+> extends FamilyDescriptor<TFamilyId> {
+  create<TTargetId extends string>(options: {
+    readonly target: RuntimeTargetDescriptor<TFamilyId, TTargetId>;
+    readonly adapter: RuntimeAdapterDescriptor<TFamilyId, TTargetId>;
+    readonly driver: RuntimeDriverDescriptor<TFamilyId, TTargetId>;
+    readonly extensionPacks: readonly RuntimeExtensionDescriptor<TFamilyId, TTargetId>[];
+  }): TFamilyInstance;
+}
+
+export interface RuntimeTargetDescriptor<
+  TFamilyId extends string,
+  TTargetId extends string,
+  TTargetInstance extends RuntimeTargetInstance<TFamilyId, TTargetId> = RuntimeTargetInstance<
+    TFamilyId,
+    TTargetId
+  >,
+> extends TargetDescriptor<TFamilyId, TTargetId> {
+  create(): TTargetInstance;
+}
+
+export interface RuntimeAdapterDescriptor<
+  TFamilyId extends string,
+  TTargetId extends string,
+  TAdapterInstance extends RuntimeAdapterInstance<TFamilyId, TTargetId> = RuntimeAdapterInstance<
+    TFamilyId,
+    TTargetId
+  >,
+> extends AdapterDescriptor<TFamilyId, TTargetId> {
+  create(): TAdapterInstance;
+}
+
+export interface RuntimeDriverDescriptor<
+  TFamilyId extends string,
+  TTargetId extends string,
+  TCreateOptions = void,
+  TDriverInstance extends RuntimeDriverInstance<TFamilyId, TTargetId> = RuntimeDriverInstance<
+    TFamilyId,
+    TTargetId
+  >,
+> extends DriverDescriptor<TFamilyId, TTargetId> {
+  create(options?: TCreateOptions): TDriverInstance;
+}
+
+export interface RuntimeExtensionDescriptor<
+  TFamilyId extends string,
+  TTargetId extends string,
+  TExtensionInstance extends RuntimeExtensionInstance<
+    TFamilyId,
+    TTargetId
+  > = RuntimeExtensionInstance<TFamilyId, TTargetId>,
+> extends ExtensionDescriptor<TFamilyId, TTargetId> {
+  create(): TExtensionInstance;
+}

package/src/execution-instances.ts

@@ -0,0 +1,22 @@
+import type {
+  AdapterInstance,
+  DriverInstance,
+  ExtensionInstance,
+  FamilyInstance,
+  TargetInstance,
+} from './framework-components';
+
+export interface RuntimeFamilyInstance<TFamilyId extends string>
+  extends FamilyInstance<TFamilyId> {}
+
+export interface RuntimeTargetInstance<TFamilyId extends string, TTargetId extends string>
+  extends TargetInstance<TFamilyId, TTargetId> {}
+
+export interface RuntimeAdapterInstance<TFamilyId extends string, TTargetId extends string>
+  extends AdapterInstance<TFamilyId, TTargetId> {}
+
+export interface RuntimeDriverInstance<TFamilyId extends string, TTargetId extends string>
+  extends DriverInstance<TFamilyId, TTargetId> {}
+
+export interface RuntimeExtensionInstance<TFamilyId extends string, TTargetId extends string>
+  extends ExtensionInstance<TFamilyId, TTargetId> {}

package/src/execution-requirements.ts

@@ -0,0 +1,47 @@
+import type {
+  RuntimeAdapterDescriptor,
+  RuntimeExtensionDescriptor,
+  RuntimeFamilyDescriptor,
+  RuntimeTargetDescriptor,
+} from './execution-descriptors';
+import { checkContractComponentRequirements } from './framework-components';
+
+export function assertRuntimeContractRequirementsSatisfied<
+  TFamilyId extends string,
+  TTargetId extends string,
+>({
+  contract,
+  family,
+  target,
+  adapter,
+  extensionPacks,
+}: {
+  readonly contract: { readonly target: string; readonly extensionPacks?: Record<string, unknown> };
+  readonly family: RuntimeFamilyDescriptor<TFamilyId>;
+  readonly target: RuntimeTargetDescriptor<TFamilyId, TTargetId>;
+  readonly adapter: RuntimeAdapterDescriptor<TFamilyId, TTargetId>;
+  readonly extensionPacks: readonly RuntimeExtensionDescriptor<TFamilyId, TTargetId>[];
+}): void {
+  const providedComponentIds = new Set<string>([family.id, target.id, adapter.id]);
+  for (const extension of extensionPacks) {
+    providedComponentIds.add(extension.id);
+  }
+
+  const result = checkContractComponentRequirements({
+    contract,
+    expectedTargetId: target.targetId,
+    providedComponentIds,
+  });
+
+  if (result.targetMismatch) {
+    throw new Error(
+      `Contract target '${result.targetMismatch.actual}' does not match runtime target descriptor '${result.targetMismatch.expected}'.`,
+    );
+  }
+
+  for (const packId of result.missingExtensionPackIds) {
+    throw new Error(
+      `Contract requires extension pack '${packId}', but runtime descriptors do not provide a matching component.`,
+    );
+  }
+}

package/src/execution-stack.ts

@@ -0,0 +1,143 @@
+import type {
+  RuntimeAdapterDescriptor,
+  RuntimeDriverDescriptor,
+  RuntimeExtensionDescriptor,
+  RuntimeTargetDescriptor,
+} from './execution-descriptors';
+import type {
+  RuntimeAdapterInstance,
+  RuntimeDriverInstance,
+  RuntimeExtensionInstance,
+  RuntimeTargetInstance,
+} from './execution-instances';
+
+export interface ExecutionStack<
+  TFamilyId extends string,
+  TTargetId extends string,
+  TAdapterInstance extends RuntimeAdapterInstance<TFamilyId, TTargetId> = RuntimeAdapterInstance<
+    TFamilyId,
+    TTargetId
+  >,
+  TDriverInstance extends RuntimeDriverInstance<TFamilyId, TTargetId> = RuntimeDriverInstance<
+    TFamilyId,
+    TTargetId
+  >,
+  TExtensionInstance extends RuntimeExtensionInstance<
+    TFamilyId,
+    TTargetId
+  > = RuntimeExtensionInstance<TFamilyId, TTargetId>,
+> {
+  readonly target: RuntimeTargetDescriptor<TFamilyId, TTargetId>;
+  readonly adapter: RuntimeAdapterDescriptor<TFamilyId, TTargetId, TAdapterInstance>;
+  readonly driver:
+    | RuntimeDriverDescriptor<TFamilyId, TTargetId, unknown, TDriverInstance>
+    | undefined;
+  readonly extensionPacks: readonly RuntimeExtensionDescriptor<
+    TFamilyId,
+    TTargetId,
+    TExtensionInstance
+  >[];
+}
+
+export interface ExecutionStackInstance<
+  TFamilyId extends string,
+  TTargetId extends string,
+  TAdapterInstance extends RuntimeAdapterInstance<TFamilyId, TTargetId> = RuntimeAdapterInstance<
+    TFamilyId,
+    TTargetId
+  >,
+  TDriverInstance extends RuntimeDriverInstance<TFamilyId, TTargetId> = RuntimeDriverInstance<
+    TFamilyId,
+    TTargetId
+  >,
+  TExtensionInstance extends RuntimeExtensionInstance<
+    TFamilyId,
+    TTargetId
+  > = RuntimeExtensionInstance<TFamilyId, TTargetId>,
+> {
+  readonly stack: ExecutionStack<
+    TFamilyId,
+    TTargetId,
+    TAdapterInstance,
+    TDriverInstance,
+    TExtensionInstance
+  >;
+  readonly target: RuntimeTargetInstance<TFamilyId, TTargetId>;
+  readonly adapter: TAdapterInstance;
+  readonly driver: TDriverInstance | undefined;
+  readonly extensionPacks: readonly TExtensionInstance[];
+}
+
+export function createExecutionStack<
+  TFamilyId extends string,
+  TTargetId extends string,
+  TTargetInstance extends RuntimeTargetInstance<TFamilyId, TTargetId>,
+  TTargetDescriptor extends RuntimeTargetDescriptor<TFamilyId, TTargetId, TTargetInstance>,
+  TAdapterInstance extends RuntimeAdapterInstance<TFamilyId, TTargetId>,
+  TAdapterDescriptor extends RuntimeAdapterDescriptor<TFamilyId, TTargetId, TAdapterInstance>,
+  TDriverInstance extends RuntimeDriverInstance<TFamilyId, TTargetId> = RuntimeDriverInstance<
+    TFamilyId,
+    TTargetId
+  >,
+  TDriverDescriptor extends
+    | RuntimeDriverDescriptor<TFamilyId, TTargetId, unknown, TDriverInstance>
+    | undefined = undefined,
+  TExtensionInstance extends RuntimeExtensionInstance<
+    TFamilyId,
+    TTargetId
+  > = RuntimeExtensionInstance<TFamilyId, TTargetId>,
+  TExtensionDescriptor extends RuntimeExtensionDescriptor<
+    TFamilyId,
+    TTargetId,
+    TExtensionInstance
+  > = never,
+>(input: {
+  readonly target: TTargetDescriptor;
+  readonly adapter: TAdapterDescriptor;
+  readonly driver?: TDriverDescriptor | undefined;
+  readonly extensionPacks?: readonly TExtensionDescriptor[] | undefined;
+}): ExecutionStack<TFamilyId, TTargetId, TAdapterInstance, TDriverInstance, TExtensionInstance> & {
+  readonly target: TTargetDescriptor;
+  readonly adapter: TAdapterDescriptor;
+  readonly driver: TDriverDescriptor | undefined;
+  readonly extensionPacks: readonly TExtensionDescriptor[];
+} {
+  return {
+    target: input.target,
+    adapter: input.adapter,
+    driver: input.driver,
+    extensionPacks: input.extensionPacks ?? [],
+  };
+}
+
+export function instantiateExecutionStack<
+  TFamilyId extends string,
+  TTargetId extends string,
+  TAdapterInstance extends RuntimeAdapterInstance<TFamilyId, TTargetId>,
+  TDriverInstance extends RuntimeDriverInstance<TFamilyId, TTargetId>,
+  TExtensionInstance extends RuntimeExtensionInstance<TFamilyId, TTargetId>,
+>(
+  stack: ExecutionStack<
+    TFamilyId,
+    TTargetId,
+    TAdapterInstance,
+    TDriverInstance,
+    TExtensionInstance
+  >,
+): ExecutionStackInstance<
+  TFamilyId,
+  TTargetId,
+  TAdapterInstance,
+  TDriverInstance,
+  TExtensionInstance
+> {
+  const driver = stack.driver ? stack.driver.create() : undefined;
+
+  return {
+    stack,
+    target: stack.target.create(),
+    adapter: stack.adapter.create(),
+    driver,
+    extensionPacks: stack.extensionPacks.map((descriptor) => descriptor.create()),
+  };
+}

package/src/exports/authoring.ts

@@ -0,0 +1,22 @@
+export type {
+  AuthoringArgRef,
+  AuthoringArgumentDescriptor,
+  AuthoringColumnDefaultTemplate,
+  AuthoringContributions,
+  AuthoringFieldNamespace,
+  AuthoringFieldPresetDescriptor,
+  AuthoringFieldPresetOutput,
+  AuthoringStorageTypeTemplate,
+  AuthoringTemplateValue,
+  AuthoringTypeConstructorDescriptor,
+  AuthoringTypeNamespace,
+} from '../framework-authoring';
+export {
+  instantiateAuthoringFieldPreset,
+  instantiateAuthoringTypeConstructor,
+  isAuthoringArgRef,
+  isAuthoringFieldPresetDescriptor,
+  isAuthoringTypeConstructorDescriptor,
+  resolveAuthoringTemplateValue,
+  validateAuthoringHelperArguments,
+} from '../framework-authoring';

package/src/exports/codec.ts

@@ -0,0 +1,2 @@
+export type { Codec, CodecLookup, CodecTrait } from '../codec-types';
+export { emptyCodecLookup } from '../codec-types';

package/src/exports/components.ts

@@ -0,0 +1,24 @@
+export type {
+  AdapterDescriptor,
+  AdapterInstance,
+  AdapterPackRef,
+  ComponentDescriptor,
+  ComponentMetadata,
+  ContractComponentRequirementsCheckInput,
+  ContractComponentRequirementsCheckResult,
+  DriverDescriptor,
+  DriverInstance,
+  DriverPackRef,
+  ExtensionDescriptor,
+  ExtensionInstance,
+  ExtensionPackRef,
+  FamilyDescriptor,
+  FamilyInstance,
+  FamilyPackRef,
+  PackRefBase,
+  TargetBoundComponentDescriptor,
+  TargetDescriptor,
+  TargetInstance,
+  TargetPackRef,
+} from '../framework-components';
+export { checkContractComponentRequirements } from '../framework-components';