/** @holoscript/core/reconstruction — HoloMap + SimulationContract binding */
export declare const HOLOMAP_SIMULATION_CONTRACT_KIND: 'holomap.reconstruction.v1';
export interface ReconstructionFrame {
  index: number;
  timestampMs: number;
  rgb: Uint8Array;
  width: number;
  height: number;
  stride: 3 | 4;
}
export interface CameraPose {
  position: [number, number, number];
  rotation: [number, number, number, number];
  confidence: number;
}
export interface PointCloudChunk {
  positions: Float32Array;
  colors: Uint8Array;
  normals?: Float32Array;
  confidence: Float32Array;
}
export interface ReconstructionStep {
  frame: ReconstructionFrame;
  pose: CameraPose;
  points: PointCloudChunk;
  trajectory: TrajectoryMemoryState;
  anchor: AnchorContextState;
}
export interface TrajectoryKeyframe {
  frameIndex: number;
  timestampMs: number;
  pose: CameraPose;
  embedding: Float32Array;
}
export interface TrajectoryMemoryState {
  keyframes: TrajectoryKeyframe[];
  estimatedDriftMeters: number;
  lastLoopClosureFrame: number;
  revision: number;
}
export interface AnchorContextState {
  anchorFrameIndex: number;
  anchorPose: CameraPose;
  anchorDescriptor: Float32Array;
  revision: number;
}
export interface HoloMapConfig {
  inputResolution: { width: number; height: number };
  targetFPS: number;
  maxSequenceLength: number;
  seed: number;
  modelHash: string;
  videoHash?: string;
  tileGrid?: number;
  weightCid?: string;
  weightUrl?: string;
  weightUrls?: string[];
  cpuOffload: boolean;
  weightStrategy?: 'distill' | 'fine-tune' | 'from-scratch';
  verticalProfile?: 'generalist' | 'indoor' | 'outdoor' | 'object';
  allowCpuFallback?: boolean;
  localResolver?: (weightCid: string) => Promise<ArrayBuffer | undefined>;
}
export declare const HOLOMAP_DEFAULTS: HoloMapConfig;
export interface ReconstructionManifest {
  version: '1.0.0';
  worldId: string;
  displayName: string;
  pointCount: number;
  frameCount: number;
  bounds: { min: [number, number, number]; max: [number, number, number] };
  replayHash: string;
  simulationContract: {
    kind: 'holomap.reconstruction.v1';
    replayFingerprint: string;
    holoScriptBuild: string;
  };
  provenance: {
    anchorHash?: string;
    opentimestampsProof?: string;
    baseCalldataTx?: string;
    capturedAtIso: string;
  };
  assets: { points: string; trajectory: string; anchors: string; splats?: string };
  weightStrategy: 'distill' | 'fine-tune' | 'from-scratch';
}
export interface HoloMapRuntime {
  init(config: HoloMapConfig): Promise<void>;
  step(frame: ReconstructionFrame): Promise<ReconstructionStep>;
  finalize(): Promise<ReconstructionManifest>;
  replayHash(): string;
  dispose(): Promise<void>;
}
export declare function createHoloMapRuntime(config?: Partial<HoloMapConfig>): HoloMapRuntime;
export declare function computeHoloMapReplayFingerprint(parts: {
  modelHash: string;
  seed: number;
  weightStrategy: string;
  videoHash?: string;
  tileGrid?: number;
  weightCid?: string;
  verticalProfile?: 'generalist' | 'indoor' | 'outdoor' | 'object';
}): string;
export declare function fnv1a32Hex(input: string): string;
export declare function assertHoloMapManifestContract(m: ReconstructionManifest): void;

/** HoloTorch WebGPU model types and shadow-only execution admission. */
export interface BlockWeights {
  ln1g: Float32Array;
  ln1b: Float32Array;
  wqkv: Float32Array;
  bqkv: Float32Array;
  wproj: Float32Array;
  bproj: Float32Array;
  ln2g: Float32Array;
  ln2b: Float32Array;
  wfc1: Float32Array;
  bfc1: Float32Array;
  wfc2: Float32Array;
  bfc2: Float32Array;
}
export interface ModelWeights {
  wte: Float32Array;
  wpe: Float32Array;
  blocks: BlockWeights[];
  lnfg: Float32Array;
  lnfb: Float32Array;
}
export interface ModelConfig { nEmbd: number; nHead: number; vocab: number; }
export interface HoloTorchModel {
  run(ids: Uint32Array, weights: ModelWeights, config: ModelConfig): Promise<Float32Array>;
}
export declare const HOLOTORCH_SHADOW_EXECUTION_SCHEMA: 'holoscript.holotorch-shadow-execution.v0.1.0';
export declare const HOLOTORCH_TENSOR_SET_SCHEMA: 'holoscript.holotorch-tensor-set.v0.1.0';
export declare const HOLOTORCH_ARTIFACT_BINDING_SCHEMA: 'holoscript.holotorch-artifact-binding.v0.1.0';
export type HoloTorchSha256 = `sha256:${string}`;
export interface HoloTorchShadowBinding {
  model: string;
  architecture: 'holo-gpt2-v0';
  config: {
    nLayer: number;
    nEmbd: number;
    nHead: number;
    vocab: number;
    maxPosition: number;
  };
  artifactBindingSha256: HoloTorchSha256;
  checkpointSha256: HoloTorchSha256;
  tokenizerSha256: HoloTorchSha256;
  expectedTensorSetSha256: HoloTorchSha256;
  kernelSetSha256: HoloTorchSha256;
  runtimeSha256: HoloTorchSha256;
  sourceRevision: string;
}
export type HoloTorchArtifactBindingMaterial = Omit<
  HoloTorchShadowBinding,
  'artifactBindingSha256'
>;
export interface HoloTorchExecutionEnvironment {
  available: boolean;
  runtime: { name: string; version: string; hostOS: string };
  adapter: {
    vendor: string;
    architecture: string;
    device: string;
    driver: string;
    fingerprintSha256: HoloTorchSha256;
  };
}
export interface HoloTorchTensorSetFingerprint {
  tensorSetSha256: HoloTorchSha256;
  tensorCount: number;
  totalBytes: number;
}
export interface HoloTorchShadowExecutionReceipt {
  schema: typeof HOLOTORCH_SHADOW_EXECUTION_SCHEMA;
  authority: 'shadow-only';
  status: 'observed';
  trust: {
    executionEvidence: 'caller-observed';
    authentication: 'self-hash-only';
    executionClass: 'one-shot-audit';
  };
  model: {
    name: string;
    architecture: 'holo-gpt2-v0';
    config: { nLayer: number; nEmbd: number; nHead: number; vocab: number; maxPosition: number };
  };
  artifact: {
    artifactBindingSha256: HoloTorchSha256;
    checkpointSha256: HoloTorchSha256;
    tokenizerSha256: HoloTorchSha256;
    tensorSetSha256: HoloTorchSha256;
    tensorCount: number;
    totalBytes: number;
  };
  runtime: {
    backend: 'holotorch-webgpu';
    kernelSetSha256: HoloTorchSha256;
    runtimeSha256: HoloTorchSha256;
    sourceRevision: string;
    name: string;
    version: string;
    hostOS: string;
    adapter: {
      vendor: string;
      architecture: string;
      device: string;
      driver: string;
      fingerprintSha256: HoloTorchSha256;
    };
  };
  input: { dtype: 'u32le'; tokenCount: number; tokenIdsSha256: HoloTorchSha256 };
  output: {
    dtype: 'f32le';
    shape: [number, number];
    logitsSha256: HoloTorchSha256;
    finite: true;
  };
  timing: { startedAt: string; durationMs: number };
  receiptSha256: HoloTorchSha256;
}
export interface HoloTorchShadowVerificationPolicy {
  artifactBindingSha256: HoloTorchSha256;
  adapterFingerprintSha256: HoloTorchSha256;
  sourceRevision: string;
}
export interface HoloTorchShadowExecutor {
  execute(ids: Uint32Array): Promise<{
    logits: Float32Array;
    receipt: HoloTorchShadowExecutionReceipt;
  }>;
}
export interface HoloTorchShadowClock { nowMs(): number; nowIso(): string; }
export declare function fingerprintHoloTorchTensorSet(
  weights: ModelWeights,
  config: ModelConfig,
): Promise<HoloTorchTensorSetFingerprint>;
export declare function deriveHoloTorchArtifactBindingSha256(
  binding: HoloTorchArtifactBindingMaterial,
): Promise<HoloTorchSha256>;
export declare function createHoloTorchShadowExecutor(args: {
  model: HoloTorchModel | null;
  weights: ModelWeights;
  config: ModelConfig;
  binding: HoloTorchShadowBinding;
  environment: HoloTorchExecutionEnvironment;
  clock?: HoloTorchShadowClock;
}): Promise<HoloTorchShadowExecutor>;
export declare function verifyHoloTorchShadowExecutionReceipt(
  value: unknown,
  expected: HoloTorchShadowVerificationPolicy,
): Promise<{ valid: boolean; errors: string[] }>;

/** @cross_perceiver_contract — perceiver-consensus receipt + per-artifact derivations */
export declare const PERCEIVER_CONSENSUS_VERSION: 'perceiver-consensus-v3';
export declare const POSITION_EPSILON: number;
export type PerceiverFactClass =
  | 'source-name'
  | 'agent-entities'
  | 'affordance-count'
  | 'affordance-names'
  | 'physical-entities'
  | 'geometry'
  | 'position';
export declare function canonicalPhysicalId(name: string): string;
export interface PerceivedAffordanceOffer {
  action: string;
  target?: string;
  [key: string]: unknown;
}
export interface PerceivedEntity {
  id: string;
  kind: 'agent';
  offerCount: number;
  offers?: PerceivedAffordanceOffer[];
  [key: string]: unknown;
}
export interface PerceivedPhysicalEntity {
  id: string;
  label?: string;
  geometry?: string;
  position?: number[];
  extent?: number;
  mobility?: 'fixed' | 'actuated';
  [key: string]: unknown;
}
export interface PerceiverDerivation {
  perceiver: string;
  artifactHash: string;
  expresses: PerceiverFactClass[];
  sourceName: string | null;
  entities: PerceivedEntity[];
  physicalEntities?: PerceivedPhysicalEntity[];
  coverageGaps: string[];
}
export interface PerceiverDisagreement {
  fact: string;
  claims: Record<string, string | number | null>;
  detail: string;
}
export interface PerceiverConsensusReceipt {
  version: typeof PERCEIVER_CONSENSUS_VERSION;
  verdict: 'CONSENSUS' | 'FALSIFIED';
  sourceName: string | null;
  perceivers: Array<{
    perceiver: string;
    artifactHash: string;
    expresses: PerceiverFactClass[];
    entityCount: number;
    physicalEntityCount: number;
    coverageGaps: string[];
  }>;
  comparedFacts: number;
  disagreements: PerceiverDisagreement[];
  receiptHash: string;
}
export declare function derivePerceiverConsensus(
  derivations: PerceiverDerivation[]
): PerceiverConsensusReceipt;
export declare const WEBGPU_PERCEIVER: 'webgpu';
export declare function deriveWebGPUPerception(artifact: string): PerceiverDerivation;
export declare const AGENT_INFERENCE_PERCEIVER: 'agent-inference';
export declare function deriveAgentInferencePerception(
  files: Record<string, string>
): PerceiverDerivation;
export declare const URDF_PERCEIVER: 'urdf';
export declare function deriveUrdfPerception(artifact: string): PerceiverDerivation;
/** @verified_view — make agent-authored 2D surfaces provenance-complete for the gate. */
export declare function enforceVerifiedViewReceipts(source: string): string;
export declare function isProvenanceComplete(source: string): boolean;
export declare function derivedProjectionNode(
  config: Record<string, unknown> | undefined
): string | null;
export type VerifiedViewViolationReason =
  | 'missing-projects'
  | 'mismatched-node'
  | 'hallucinated-root'
  | 'projects-without-binding'
  | 'no-verified-view';
export interface VerifiedViewViolation {
  element: string;
  node: string | null;
  reason: VerifiedViewViolationReason;
  detail: string;
}
export interface VerifiedViewDiagnosis {
  parsed: boolean;
  hasBindings: boolean;
  verifiedViewOn: boolean;
  complete: boolean;
  violations: VerifiedViewViolation[];
}
export declare function diagnoseVerifiedView(source: string): VerifiedViewDiagnosis;
export declare const SURFACE_TWIN_VERSION: 'surface-twin-v1';
export type SurfaceTwinScalar = string | number | boolean | null;
export interface SurfaceTwinTransform {
  precision?: number;
  prefix?: string;
  suffix?: string;
}
export interface SurfaceTwinProjection {
  element: string;
  node: string;
  entity?: string;
  identity: boolean;
  transform?: SurfaceTwinTransform;
}
export interface SurfaceTwinDivergence {
  node: string;
  entity: string;
  displayed: SurfaceTwinScalar;
  authoritative: SurfaceTwinScalar;
  expected?: SurfaceTwinScalar;
  detail: string;
}
export type SurfaceTwinAbstentionReason =
  | 'no-entity-binding'
  | 'non-identity-transform'
  | 'authority-unavailable'
  | 'authority-missing'
  | 'display-missing';
export interface SurfaceTwinAbstention {
  node: string;
  entity?: string;
  reason: SurfaceTwinAbstentionReason;
}
export interface SurfaceTwinReceipt {
  version: typeof SURFACE_TWIN_VERSION;
  verdict: 'CONSENSUS' | 'FALSIFIED';
  checked: number;
  divergences: SurfaceTwinDivergence[];
  abstentions: SurfaceTwinAbstention[];
  receiptHash: string;
}
export interface SurfaceTwinInput {
  contract: { projections: SurfaceTwinProjection[] };
  displayedValues: Record<string, SurfaceTwinScalar>;
  authoritativeState: Record<string, Record<string, unknown> | SurfaceTwinScalar>;
  unavailableEntities?: readonly string[];
}
export declare function checkSurfaceTwinCorrespondence(input: SurfaceTwinInput): SurfaceTwinReceipt;
export declare function applyProjectionTransform(raw: SurfaceTwinScalar, transform: SurfaceTwinTransform): string;
export type AuthoritativeStateFetcher = (
  entity: string
) => Promise<Record<string, unknown> | SurfaceTwinScalar | null | undefined>;
export declare function verifySurfaceTwinLive(input: {
  contract: { projections: SurfaceTwinProjection[] };
  displayedValues: Record<string, SurfaceTwinScalar>;
  fetchAuthoritativeState: AuthoritativeStateFetcher;
}): Promise<SurfaceTwinReceipt>;
export declare function extractDisplayedProjections(html: string): Record<string, string>;