@pulse-compute/wasm-contracts 0.0.0 → 1.0.0-beta.1

package/src/project/reachable-graph-identity.js

@@ -0,0 +1,219 @@
+'use strict';
+
+const { prefixedStableId, stableStringify, sha256Hex } = require('../stable-id.js');
+const {
+  normalizePortablePath,
+  normalizeModuleSpecifier
+} = require('./reachable-graph-resolver.js');
+
+const REACHABLE_GRAPH_IDENTITY_VERSION = 'pulse.reachable-graph-identity.v1';
+const MODULE_STABLE_INPUT_VERSION = 'pulse.reachable-module-stable-input.v1';
+const EDGE_STABLE_INPUT_VERSION = 'pulse.reachable-edge-stable-input.v1';
+const HANDLER_REFERENCE_V2_VERSION = 'pulse.handler-reference.v2';
+const CYCLE_STABLE_INPUT_VERSION = 'pulse.reachable-cycle-stable-input.v1';
+const UNSUPPORTED_BOUNDARY_STABLE_INPUT_VERSION = 'pulse.unsupported-module-boundary-stable-input.v1';
+
+function isPlainObject(value) {
+  if (!value || typeof value !== 'object' || Array.isArray(value)) return false;
+  const proto = Object.getPrototypeOf(value);
+  return proto === Object.prototype || proto === null;
+}
+
+function assertString(value, field) {
+  if (typeof value !== 'string' || value.trim() === '') throw new TypeError(`${field} must be a non-empty string.`);
+  if (value.includes('\0')) throw new TypeError(`${field} must not contain NUL.`);
+  return value.trim();
+}
+
+function assertSha256(value, field) {
+  const text = assertString(value, field);
+  if (!/^[0-9a-f]{64}$/.test(text)) throw new TypeError(`${field} must be a lowercase SHA-256 hex string.`);
+  return text;
+}
+
+function nullableString(value, field) {
+  return value == null ? null : assertString(value, field);
+}
+
+function sortedStrings(input, field) {
+  if (input == null) return Object.freeze([]);
+  if (!Array.isArray(input)) throw new TypeError(`${field} must be an array.`);
+  return Object.freeze(Array.from(new Set(input.map((value, index) => assertString(value, `${field}[${index}]`)))).sort());
+}
+
+function normalizeSourceLocation(input, field = 'source') {
+  if (!isPlainObject(input)) throw new TypeError(`${field} must be an object.`);
+  const line = Number(input.line);
+  const column = Number(input.column);
+  if (!Number.isSafeInteger(line) || line < 1) throw new TypeError(`${field}.line must be a positive safe integer.`);
+  if (!Number.isSafeInteger(column) || column < 1) throw new TypeError(`${field}.column must be a positive safe integer.`);
+  return Object.freeze({
+    file: normalizePortablePath(input.file, `${field}.file`),
+    line,
+    column
+  });
+}
+
+function normalizePackageName(value, field = 'packageName') {
+  const name = assertString(value, field);
+  const pattern = /^(?:@[a-z0-9][a-z0-9._-]*\/[a-z0-9][a-z0-9._-]*|[a-z0-9][a-z0-9._-]*)$/i;
+  if (!pattern.test(name)) throw new TypeError(`${field} must be a valid package name.`);
+  return name;
+}
+
+function normalizePackageSubpath(value, field = 'packageSubpath') {
+  if (value == null || value === '' || value === '.') return '.';
+  const text = assertString(value, field).replace(/\\/g, '/');
+  const withPrefix = text.startsWith('./') ? text : `./${text}`;
+  const pathPart = normalizePortablePath(withPrefix.slice(2), field);
+  return `./${pathPart}`;
+}
+
+function moduleIdentityInput(input) {
+  if (!isPlainObject(input)) throw new TypeError('Module identity input must be an object.');
+  const kind = assertString(input.kind, 'module.kind');
+  if (kind === 'project') {
+    const modulePath = normalizePortablePath(input.path, 'module.path');
+    return Object.freeze({
+      artifact: MODULE_STABLE_INPUT_VERSION,
+      kind,
+      path: modulePath
+    });
+  }
+  if (kind === 'package') {
+    return Object.freeze({
+      artifact: MODULE_STABLE_INPUT_VERSION,
+      kind,
+      packageName: normalizePackageName(input.packageName),
+      packageVersion: assertString(input.packageVersion, 'module.packageVersion'),
+      packageSubpath: normalizePackageSubpath(input.packageSubpath),
+      packageManifestHash: assertSha256(input.packageManifestHash, 'module.packageManifestHash')
+    });
+  }
+  if (kind === 'generated') {
+    return Object.freeze({
+      artifact: MODULE_STABLE_INPUT_VERSION,
+      kind,
+      generator: assertString(input.generator, 'module.generator'),
+      logicalName: assertString(input.logicalName, 'module.logicalName')
+    });
+  }
+  if (kind === 'external') {
+    return Object.freeze({
+      artifact: MODULE_STABLE_INPUT_VERSION,
+      kind,
+      specifier: normalizeModuleSpecifier(input.specifier, 'module.specifier')
+    });
+  }
+  throw new TypeError(`Unsupported module identity kind ${kind}.`);
+}
+
+function createModuleIdentity(input) {
+  const stableInput = moduleIdentityInput(input);
+  const canonical = stableInput.kind === 'project'
+    ? `project:${stableInput.path}`
+    : stableInput.kind === 'package'
+      ? `package:${stableInput.packageName}@${stableInput.packageVersion}:${stableInput.packageSubpath}`
+      : stableInput.kind === 'generated'
+        ? `generated:${stableInput.generator}:${stableInput.logicalName}`
+        : `external:${stableInput.specifier}`;
+  return Object.freeze({
+    version: REACHABLE_GRAPH_IDENTITY_VERSION,
+    id: prefixedStableId(`module_${stableInput.kind}`, stableInput, { length: 32 }),
+    canonical,
+    stableInput
+  });
+}
+
+function createEdgeIdentity(input) {
+  if (!isPlainObject(input)) throw new TypeError('Edge identity input must be an object.');
+  const stableInput = Object.freeze({
+    artifact: EDGE_STABLE_INPUT_VERSION,
+    kind: assertString(input.kind, 'edge.kind'),
+    from: assertString(input.from, 'edge.from'),
+    to: assertString(input.to, 'edge.to'),
+    specifier: normalizeModuleSpecifier(input.specifier, 'edge.specifier'),
+    resolutionKind: assertString(input.resolutionKind, 'edge.resolutionKind'),
+    runtime: Boolean(input.runtime),
+    importedNames: sortedStrings(input.importedNames, 'edge.importedNames'),
+    exportedNames: sortedStrings(input.exportedNames, 'edge.exportedNames'),
+    packageContract: nullableString(input.packageContract, 'edge.packageContract'),
+    source: normalizeSourceLocation(input.source, 'edge.source')
+  });
+  return Object.freeze({
+    version: REACHABLE_GRAPH_IDENTITY_VERSION,
+    id: prefixedStableId('edge', stableInput, { length: 32 }),
+    stableInput
+  });
+}
+
+function createHandlerReferenceIdentity(input) {
+  if (!isPlainObject(input)) throw new TypeError('Handler reference identity input must be an object.');
+  const stableInput = Object.freeze({
+    artifact: HANDLER_REFERENCE_V2_VERSION,
+    moduleId: assertString(input.moduleId, 'handler.moduleId'),
+    exportName: nullableString(input.exportName, 'handler.exportName'),
+    localName: nullableString(input.localName, 'handler.localName'),
+    role: assertString(input.role, 'handler.role'),
+    wrappers: sortedStrings(input.wrappers, 'handler.wrappers'),
+    source: normalizeSourceLocation(input.source, 'handler.source')
+  });
+  if (stableInput.exportName === null && stableInput.localName === null) {
+    throw new TypeError('Handler reference requires exportName or localName.');
+  }
+  return Object.freeze({
+    version: REACHABLE_GRAPH_IDENTITY_VERSION,
+    id: prefixedStableId('handlerref', stableInput, { length: 32 }),
+    stableInput
+  });
+}
+
+function createCycleIdentity(moduleIdsInput) {
+  const moduleIds = sortedStrings(moduleIdsInput, 'cycle.modules');
+  if (moduleIds.length === 0) throw new TypeError('cycle.modules must be non-empty.');
+  const stableInput = Object.freeze({ artifact: CYCLE_STABLE_INPUT_VERSION, modules: moduleIds });
+  return Object.freeze({
+    version: REACHABLE_GRAPH_IDENTITY_VERSION,
+    id: prefixedStableId('cycle', stableInput, { length: 32 }),
+    stableInput
+  });
+}
+
+function createUnsupportedBoundaryIdentity(input) {
+  if (!isPlainObject(input)) throw new TypeError('Unsupported boundary identity input must be an object.');
+  const stableInput = Object.freeze({
+    artifact: UNSUPPORTED_BOUNDARY_STABLE_INPUT_VERSION,
+    kind: assertString(input.kind, 'boundary.kind'),
+    from: nullableString(input.from, 'boundary.from'),
+    specifier: normalizeModuleSpecifier(input.specifier, 'boundary.specifier'),
+    source: normalizeSourceLocation(input.source, 'boundary.source')
+  });
+  return Object.freeze({
+    version: REACHABLE_GRAPH_IDENTITY_VERSION,
+    id: prefixedStableId('boundary', stableInput, { length: 32 }),
+    stableInput
+  });
+}
+
+function graphSemanticHash(input) {
+  return sha256Hex(stableStringify(input));
+}
+
+module.exports = Object.freeze({
+  REACHABLE_GRAPH_IDENTITY_VERSION,
+  MODULE_STABLE_INPUT_VERSION,
+  EDGE_STABLE_INPUT_VERSION,
+  HANDLER_REFERENCE_V2_VERSION,
+  CYCLE_STABLE_INPUT_VERSION,
+  UNSUPPORTED_BOUNDARY_STABLE_INPUT_VERSION,
+  normalizeSourceLocation,
+  normalizePackageName,
+  normalizePackageSubpath,
+  moduleIdentityInput,
+  createModuleIdentity,
+  createEdgeIdentity,
+  createHandlerReferenceIdentity,
+  createCycleIdentity,
+  createUnsupportedBoundaryIdentity,
+  graphSemanticHash
+});

package/src/project/reachable-graph-projections.js

@@ -0,0 +1,279 @@
+'use strict';
+
+const { prefixedStableId, stableStringify, sha256Hex } = require('../stable-id.js');
+const { normalizeSourceLocation, normalizePackageName, normalizePackageSubpath } = require('./reachable-graph-identity.js');
+
+const PACKAGE_REACHABILITY_PROJECTION_VERSION = 'pulse.package-reachability-projection.v1';
+const PACKAGE_BINDING_OWNERSHIP_VERSION = 'pulse.package-binding-ownership.v1';
+const APPLICATION_ENTRY_SAFETY_VERSION = 'pulse.application-entry-safety.v1';
+const NATIVE_ELIGIBILITY_PROJECTION_VERSION = 'pulse.native-eligibility-projection.v1';
+
+const PACKAGE_NATIVE_STATUSES = Object.freeze(['core-authoring', 'trusted-lowerable', 'unsupported']);
+const PACKAGE_BINDING_VIA = Object.freeze(['direct-import', 'direct-re-export', 'project-import', 'project-re-export']);
+const ELIGIBILITY_BLOCKER_KINDS = Object.freeze([
+  'unsupported-package',
+  'unsupported-package-subpath',
+  'package-re-export-lowering-deferred',
+  'package-composition-not-realized',
+  'application-entry-lifecycle-side-effect'
+]);
+
+function isPlainObject(value) {
+  if (!value || typeof value !== 'object' || Array.isArray(value)) return false;
+  const proto = Object.getPrototypeOf(value);
+  return proto === Object.prototype || proto === null;
+}
+
+function assertKnownKeys(input, allowed, field) {
+  for (const key of Object.keys(input)) if (!allowed.has(key)) throw new TypeError(`${field} contains unsupported field ${key}.`);
+}
+
+function string(value, field) {
+  if (typeof value !== 'string' || value.trim() === '') throw new TypeError(`${field} must be a non-empty string.`);
+  if (value.includes('\0')) throw new TypeError(`${field} must not contain NUL.`);
+  return value.trim();
+}
+
+function nullableString(value, field) {
+  return value == null ? null : string(value, field);
+}
+
+function bool(value, field) {
+  if (typeof value !== 'boolean') throw new TypeError(`${field} must be a boolean.`);
+  return value;
+}
+
+function strings(values, field) {
+  if (values == null) return Object.freeze([]);
+  if (!Array.isArray(values)) throw new TypeError(`${field} must be an array.`);
+  return Object.freeze(Array.from(new Set(values.map((value, index) => string(value, `${field}[${index}]`)))).sort());
+}
+
+function sources(values, field) {
+  if (values == null) return Object.freeze([]);
+  if (!Array.isArray(values)) throw new TypeError(`${field} must be an array.`);
+  const normalized = values.map((value, index) => normalizeSourceLocation(value, `${field}[${index}]`));
+  normalized.sort((left, right) => left.file.localeCompare(right.file) || left.line - right.line || left.column - right.column);
+  return Object.freeze(normalized);
+}
+
+function compareSource(left, right) {
+  return left.source.file.localeCompare(right.source.file)
+    || left.source.line - right.source.line
+    || left.source.column - right.source.column
+    || String(left.id || left.edgeId || '').localeCompare(String(right.id || right.edgeId || ''));
+}
+
+function normalizePackageRecord(input, index) {
+  if (!isPlainObject(input)) throw new TypeError(`packages[${index}] must be an object.`);
+  assertKnownKeys(input, new Set([
+    'moduleId', 'packageName', 'packageVersion', 'packageSubpath', 'owner', 'runtime',
+    'contractId', 'lowerableSubpath', 'facadeSymbols', 'importSources', 'reExportSources', 'nativeStatus'
+  ]), `packages[${index}]`);
+  const nativeStatus = string(input.nativeStatus, `packages[${index}].nativeStatus`);
+  if (!PACKAGE_NATIVE_STATUSES.includes(nativeStatus)) throw new TypeError(`Unsupported package native status ${nativeStatus}.`);
+  return Object.freeze({
+    moduleId: string(input.moduleId, `packages[${index}].moduleId`),
+    packageName: normalizePackageName(input.packageName, `packages[${index}].packageName`),
+    packageVersion: string(input.packageVersion, `packages[${index}].packageVersion`),
+    packageSubpath: normalizePackageSubpath(input.packageSubpath, `packages[${index}].packageSubpath`),
+    owner: string(input.owner, `packages[${index}].owner`),
+    runtime: bool(input.runtime, `packages[${index}].runtime`),
+    contractId: nullableString(input.contractId, `packages[${index}].contractId`),
+    lowerableSubpath: nullableString(input.lowerableSubpath, `packages[${index}].lowerableSubpath`),
+    facadeSymbols: strings(input.facadeSymbols, `packages[${index}].facadeSymbols`),
+    importSources: sources(input.importSources, `packages[${index}].importSources`),
+    reExportSources: sources(input.reExportSources, `packages[${index}].reExportSources`),
+    nativeStatus
+  });
+}
+
+function normalizeBinding(input, index) {
+  if (!isPlainObject(input)) throw new TypeError(`bindings[${index}] must be an object.`);
+  assertKnownKeys(input, new Set([
+    'moduleId', 'localName', 'exportName', 'importedName', 'packageModuleId', 'packageName',
+    'contractId', 'source', 'via', 'direct', 'used'
+  ]), `bindings[${index}]`);
+  const via = string(input.via, `bindings[${index}].via`);
+  if (!PACKAGE_BINDING_VIA.includes(via)) throw new TypeError(`Unsupported package binding path ${via}.`);
+  const normalized = {
+    version: PACKAGE_BINDING_OWNERSHIP_VERSION,
+    moduleId: string(input.moduleId, `bindings[${index}].moduleId`),
+    localName: nullableString(input.localName, `bindings[${index}].localName`),
+    exportName: nullableString(input.exportName, `bindings[${index}].exportName`),
+    importedName: string(input.importedName, `bindings[${index}].importedName`),
+    packageModuleId: string(input.packageModuleId, `bindings[${index}].packageModuleId`),
+    packageName: normalizePackageName(input.packageName, `bindings[${index}].packageName`),
+    contractId: nullableString(input.contractId, `bindings[${index}].contractId`),
+    source: normalizeSourceLocation(input.source, `bindings[${index}].source`),
+    via,
+    direct: bool(input.direct, `bindings[${index}].direct`),
+    used: bool(input.used, `bindings[${index}].used`)
+  };
+  if (normalized.localName === null && normalized.exportName === null) throw new TypeError(`bindings[${index}] requires localName or exportName.`);
+  const stableInput = Object.freeze({
+    version: PACKAGE_BINDING_OWNERSHIP_VERSION,
+    moduleId: normalized.moduleId,
+    localName: normalized.localName,
+    exportName: normalized.exportName,
+    importedName: normalized.importedName,
+    packageModuleId: normalized.packageModuleId,
+    packageName: normalized.packageName,
+    contractId: normalized.contractId,
+    source: normalized.source,
+    via: normalized.via
+  });
+  return Object.freeze({ ...normalized, id: prefixedStableId('pkgbinding', stableInput, { length: 32 }) });
+}
+
+function normalizePackageReachabilityProjection(input) {
+  if (!isPlainObject(input)) throw new TypeError('Package reachability projection must be an object.');
+  assertKnownKeys(input, new Set(['graphVersion', 'graphHash', 'packages', 'bindings', 'selectedContracts']), 'Package reachability projection');
+  const packages = Object.freeze([...(input.packages || [])].map(normalizePackageRecord)
+    .sort((left, right) => left.packageName.localeCompare(right.packageName) || left.packageSubpath.localeCompare(right.packageSubpath) || left.moduleId.localeCompare(right.moduleId)));
+  if (new Set(packages.map((entry) => entry.moduleId)).size !== packages.length) throw new TypeError('Package reachability module identities must be unique.');
+  const bindings = Object.freeze([...(input.bindings || [])].map(normalizeBinding)
+    .sort((left, right) => left.moduleId.localeCompare(right.moduleId) || (left.localName || left.exportName).localeCompare(right.localName || right.exportName) || left.id.localeCompare(right.id)));
+  if (new Set(bindings.map((entry) => entry.id)).size !== bindings.length) throw new TypeError('Package binding identities must be unique.');
+  const semantic = Object.freeze({
+    version: PACKAGE_REACHABILITY_PROJECTION_VERSION,
+    graphVersion: string(input.graphVersion, 'graphVersion'),
+    graphHash: string(input.graphHash, 'graphHash'),
+    packages,
+    bindings,
+    selectedContracts: strings(input.selectedContracts, 'selectedContracts'),
+    policy: Object.freeze({
+      packageUseFromResolvedReachabilityOnly: true,
+      typeOnlyImportsActivateContracts: false,
+      substringSelection: false,
+      firstPartyLowerersOnly: true,
+      publicPluginApi: false
+    })
+  });
+  return Object.freeze({ ...semantic, projectionHash: sha256Hex(stableStringify(semantic)) });
+}
+
+function normalizeLifecycleEdge(input, index) {
+  if (!isPlainObject(input)) throw new TypeError(`lifecycleEdges[${index}] must be an object.`);
+  assertKnownKeys(input, new Set(['edgeId', 'moduleId', 'packageModuleId', 'packageName', 'symbol', 'source']), `lifecycleEdges[${index}]`);
+  return Object.freeze({
+    edgeId: string(input.edgeId, `lifecycleEdges[${index}].edgeId`),
+    moduleId: string(input.moduleId, `lifecycleEdges[${index}].moduleId`),
+    packageModuleId: string(input.packageModuleId, `lifecycleEdges[${index}].packageModuleId`),
+    packageName: normalizePackageName(input.packageName, `lifecycleEdges[${index}].packageName`),
+    symbol: string(input.symbol, `lifecycleEdges[${index}].symbol`),
+    source: normalizeSourceLocation(input.source, `lifecycleEdges[${index}].source`)
+  });
+}
+
+function normalizeApplicationEntrySafety(input) {
+  if (!isPlainObject(input)) throw new TypeError('Application entry safety projection must be an object.');
+  assertKnownKeys(input, new Set(['graphHash', 'lifecycleEdges']), 'Application entry safety projection');
+  const lifecycleEdges = Object.freeze([...(input.lifecycleEdges || [])].map(normalizeLifecycleEdge).sort(compareSource));
+  const semantic = Object.freeze({
+    version: APPLICATION_ENTRY_SAFETY_VERSION,
+    graphHash: string(input.graphHash, 'graphHash'),
+    importSafe: lifecycleEdges.length === 0,
+    lifecycleEdges,
+    firstLifecycleEdge: lifecycleEdges.length === 0 ? null : lifecycleEdges[0],
+    policy: Object.freeze({
+      knownPulseLifecycleOperationsOnly: true,
+      arbitraryPurityAnalysis: false,
+      lifecycleOwnership: 'provider',
+      configuredEntryMustBeImportSafe: true
+    })
+  });
+  return Object.freeze({ ...semantic, projectionHash: sha256Hex(stableStringify(semantic)) });
+}
+
+function normalizeEligibilityBlocker(input, index) {
+  if (!isPlainObject(input)) throw new TypeError(`blockers[${index}] must be an object.`);
+  assertKnownKeys(input, new Set([
+    'kind', 'code', 'moduleId', 'handlerIds', 'packageName', 'packageSubpath', 'contractId',
+    'specifier', 'source', 'message'
+  ]), `blockers[${index}]`);
+  const kind = string(input.kind, `blockers[${index}].kind`);
+  if (!ELIGIBILITY_BLOCKER_KINDS.includes(kind)) throw new TypeError(`Unsupported native eligibility blocker ${kind}.`);
+  const normalized = {
+    kind,
+    code: string(input.code, `blockers[${index}].code`),
+    moduleId: string(input.moduleId, `blockers[${index}].moduleId`),
+    handlerIds: strings(input.handlerIds, `blockers[${index}].handlerIds`),
+    packageName: nullableString(input.packageName, `blockers[${index}].packageName`),
+    packageSubpath: input.packageSubpath == null ? null : normalizePackageSubpath(input.packageSubpath, `blockers[${index}].packageSubpath`),
+    contractId: nullableString(input.contractId, `blockers[${index}].contractId`),
+    specifier: string(input.specifier, `blockers[${index}].specifier`),
+    source: normalizeSourceLocation(input.source, `blockers[${index}].source`),
+    message: string(input.message, `blockers[${index}].message`)
+  };
+  const stableInput = Object.freeze({ version: NATIVE_ELIGIBILITY_PROJECTION_VERSION, ...normalized });
+  return Object.freeze({ ...normalized, id: prefixedStableId('eligibility', stableInput, { length: 32 }) });
+}
+
+function normalizeHandlerEligibility(input, index) {
+  if (!isPlainObject(input)) throw new TypeError(`handlers[${index}] must be an object.`);
+  assertKnownKeys(input, new Set(['handlerId', 'moduleId', 'eligible', 'blockerIds']), `handlers[${index}]`);
+  return Object.freeze({
+    handlerId: string(input.handlerId, `handlers[${index}].handlerId`),
+    moduleId: string(input.moduleId, `handlers[${index}].moduleId`),
+    eligible: bool(input.eligible, `handlers[${index}].eligible`),
+    blockerIds: strings(input.blockerIds, `handlers[${index}].blockerIds`)
+  });
+}
+
+function normalizeNativeEligibilityProjection(input) {
+  if (!isPlainObject(input)) throw new TypeError('Native eligibility projection must be an object.');
+  assertKnownKeys(input, new Set(['graphHash', 'blockers', 'handlers']), 'Native eligibility projection');
+  const blockers = Object.freeze([...(input.blockers || [])].map(normalizeEligibilityBlocker).sort(compareSource));
+  if (new Set(blockers.map((entry) => entry.id)).size !== blockers.length) throw new TypeError('Native eligibility blocker identities must be unique.');
+  const handlers = Object.freeze([...(input.handlers || [])].map(normalizeHandlerEligibility)
+    .sort((left, right) => left.handlerId.localeCompare(right.handlerId)));
+  const semantic = Object.freeze({
+    version: NATIVE_ELIGIBILITY_PROJECTION_VERSION,
+    graphHash: string(input.graphHash, 'graphHash'),
+    eligible: blockers.length === 0,
+    blockers,
+    firstUnsupportedBoundary: blockers.length === 0 ? null : blockers[0],
+    handlers,
+    policy: Object.freeze({
+      automaticFallback: false,
+      selectedTargetChangesEligibility: false,
+      packageUseFromResolvedGraphOnly: true,
+      routeProjectionDeferred: true
+    })
+  });
+  return Object.freeze({ ...semantic, projectionHash: sha256Hex(stableStringify(semantic)) });
+}
+
+function defaultReachableGraphProjectionContract() {
+  return Object.freeze({
+    packageReachabilityVersion: PACKAGE_REACHABILITY_PROJECTION_VERSION,
+    packageBindingVersion: PACKAGE_BINDING_OWNERSHIP_VERSION,
+    applicationEntrySafetyVersion: APPLICATION_ENTRY_SAFETY_VERSION,
+    nativeEligibilityVersion: NATIVE_ELIGIBILITY_PROJECTION_VERSION,
+    packageNativeStatuses: PACKAGE_NATIVE_STATUSES,
+    packageBindingPaths: PACKAGE_BINDING_VIA,
+    eligibilityBlockerKinds: ELIGIBILITY_BLOCKER_KINDS,
+    policies: Object.freeze({
+      graphManifestVersionUnchanged: true,
+      projectionsDerivedFromAuthoritativeGraph: true,
+      packageLoweringSeamUnchanged: true,
+      externalCompilerPlugins: false,
+      automaticTargetFallback: false
+    })
+  });
+}
+
+module.exports = Object.freeze({
+  PACKAGE_REACHABILITY_PROJECTION_VERSION,
+  PACKAGE_BINDING_OWNERSHIP_VERSION,
+  APPLICATION_ENTRY_SAFETY_VERSION,
+  NATIVE_ELIGIBILITY_PROJECTION_VERSION,
+  PACKAGE_NATIVE_STATUSES,
+  PACKAGE_BINDING_VIA,
+  ELIGIBILITY_BLOCKER_KINDS,
+  normalizePackageReachabilityProjection,
+  normalizeApplicationEntrySafety,
+  normalizeNativeEligibilityProjection,
+  defaultReachableGraphProjectionContract
+});