Universal Runtime Cognition
Infrastructure

npm install webweavex

import { UniversalInput, runCanonicalPipeline } from 'webweavex';

const input = new UniversalInput({
  source: 'https://example.com/app',
  sourceType: 'web',
  session: { authToken: 'authorized_user_session' }
});

const result = await runCanonicalPipeline(input);
console.log(`Pipeline Digest: ${result.pipelineHash}`);

dart pub add webweavex

import 'package:webweavex/webweavex.dart';

void main() async {
  final input = UniversalInput(
    source: 'https://example.com/app',
    sourceType: 'web',
  );
  final result = await runCanonicalPipeline(input);
  print('Pipeline Hash: ${result.pipelineHash}');
}

implementation 'io.github.piyush-mishra-00:webweavex:3.0.0'

<dependency>
  <groupId>io.github.piyush-mishra-00</groupId>
  <artifactId>webweavex</artifactId>
  <version>3.0.0</version>
</dependency>

import io.webweavex.WebWeaveX;
import io.webweavex.crypto.Hashing;
import io.webweavex.determinism.StableSerialize;
import io.webweavex.replay.ReplayEquivalence;
import java.util.*;

public class App {
    public static void main(String[] args) {
        System.out.println("WebWeaveX Java SDK v" + WebWeaveX.VERSION);

        Map<String, Object> data = new LinkedHashMap<>();
        data.put("b", 2);
        data.put("a", 1);

        String canonical = StableSerialize.stableSerialize(data);
        String hash      = Hashing.computeDeterministicHash(data);

        Map<String, Object> env = Map.of("browser_ir", Map.of("runtime_identity", "test"));
        Map<String, Object> r   = ReplayEquivalence.validate(env, new LinkedHashMap<>(env));
        System.out.println("equivalent=" + r.get("equivalent"));
    }
}

curl -L -o webweavex-kotlin-3.0.0.jar \
  https://github.com/ni-sh-a-char/WebWeaveX/raw/kotlin/kotlin/dist/webweavex-kotlin-3.0.0.jar

dependencies {
    implementation(files("libs/webweavex-kotlin-3.0.0.jar"))
}

import io.webweavex.runtime.RuntimeKernel
import io.webweavex.runtime.UniversalInput
import io.webweavex.fingerprint.Fingerprint

fun main() {
    val kernel = RuntimeKernel()
    val input  = UniversalInput("https://example.com")

    val output = kernel.extract(input)
    println("Version:     ${kernel.version}")
    println("Fingerprint: ${Fingerprint.compute(input.toMap())}")
}