Platforms &
Installation

pip install webweavex

# with browser automation (Playwright)
pip install "webweavex[browser]"
python -m playwright install chromium

# everything
pip install "webweavex[full]"

from webweavex import UniversalInput, run_canonical_pipeline

spec = UniversalInput(
    source="https://example.com",
    source_type="web",
)

result = run_canonical_pipeline(spec)
print(result.pipeline_hash)   # deterministic SHA-256 digest

from webweavex import (
    extract, extract_async, extract_repo, extract_docs,
    extract_web, extract_repository, extract_multimodal,
)

# Generic entry point
doc = extract("https://example.com")

# Repository cognition — builds a knowledge graph of a codebase
repo = extract_repository("./my-project")

# Multimodal (images, PDFs, documents)
media = extract_multimodal("./report.pdf")

from webweavex import (
    build_runtime_graph, query_runtime_graph,
    compute_global_runtime_fingerprint,
    validate_replay_equivalence,
)

graph = build_runtime_graph([ir_a, ir_b])
nodes = query_runtime_graph(graph, {"type": "element"})

fp = compute_global_runtime_fingerprint(graph)

# Prove two runs are topologically identical
assert validate_replay_equivalence(run_one, run_two)

from webweavex import (
    encrypt_value, decrypt_value,
    encrypt_session_state, decrypt_session_state,
    save_encrypted_session, load_encrypted_session,
    compute_kaalka_hash, fingerprint,
)

blob = encrypt_session_state({"auth_token": "..."})
save_encrypted_session("session.enc", blob)

restored = decrypt_session_state(load_encrypted_session("session.enc"))

npm install webweavex
# or
pnpm add webweavex
yarn add webweavex

import { UniversalInput, runCanonicalPipeline, VERSION } from "webweavex";

const input = new UniversalInput({
  source: "https://example.com",
  sourceType: "web",
});

const result = await runCanonicalPipeline(input);
console.log(VERSION, result.pipelineHash);

import {
  extractWeb, renderPage, captureRuntime,
  createRuntimeSession, persistRuntimeSession, restoreRuntimeSession,
  continueAuthenticatedRuntime, extractWithSession,
  detectSpaFramework, stabilizeSpaDom,
} from "webweavex";

const session = await createRuntimeSession({ source: "https://app.example.com" });
await persistRuntimeSession(session, "session.enc");

// Later — resume without re-authenticating
const resumed = await restoreRuntimeSession("session.enc");
const page    = await extractWithSession("https://app.example.com/dashboard", resumed);

import {
  computeGlobalRuntimeFingerprint,
  computeStableDomHash, computeSpaFingerprint,
  validateReplayEquivalence, replayRuntimeState,
  reconstructRuntime, rebuildExecutionGraph,
} from "webweavex";

const domHash = computeStableDomHash(html);
const equal   = validateReplayEquivalence(runA, runB);
const rebuilt = reconstructRuntime(intermediateRepresentation);

import {
  buildRuntimeMemory, mergeRuntimeMemories, queryRuntimeMemory,
  saveRuntimeMemory, loadRuntimeMemory, stableMemoryHash,
} from "webweavex";

const mem    = buildRuntimeMemory(extractions);
const merged = mergeRuntimeMemories([mem, priorMemory]);
await saveRuntimeMemory(merged, "memory.enc");

dart pub add webweavex
# Flutter
flutter pub add webweavex

import 'package:webweavex/webweavex.dart';

void main() {
  // Python-aligned canonical entry points
  final fp = computeGlobalRuntimeFingerprint(graph);
  final ok = validateReplayEquivalence(runA, runB);
  final rebuilt = reconstructRuntime(ir);

  print('fingerprint: $fp  replay-equivalent: $ok');
}

import 'package:webweavex/webweavex.dart';

void main() {
  final soup = Soup(htmlString);

  final semantic = extractSemanticHtml(htmlString);
  final content  = extractSemanticContent(htmlString);

  // Ingestion auto-detects the input kind
  final kind = detectInputType(source);
  final data = ingestInput(source);
}

import 'package:webweavex/webweavex.dart';

// Repair a selector that drifted between releases
final healed = healSelector(brokenSelector, dom);
final anchor = buildSemanticAnchor(element);

// Replay a recorded interaction sequence
replayInteractions(recordedEvents);

// Pagination and modal recovery
final pages = extractPaginatedContent(config);
final modal = recoverModalRuntime(state);

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

dependencies {
    implementation("io.github.piyush-mishra-00:webweavex:3.0.0")
}

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

import io.webweavex.WebWeaveX;
import io.webweavex.crypto.Hashing;
import io.webweavex.determinism.GlobalRuntimeFingerprint;
import io.webweavex.determinism.StableSerialize;
import io.webweavex.graph.RuntimeGraph;
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);

        // 1. Deterministic canonical serialization
        Map<String, Object> data = new LinkedHashMap<>();
        data.put("b", 2);
        data.put("a", 1);
        String canonical = StableSerialize.stableSerialize(data);
        String hash      = Hashing.computeDeterministicHash(data);

        // 2. Global runtime fingerprint
        String fp = GlobalRuntimeFingerprint.compute(new HashMap<>());

        // 3. Graph normalization
        Map<String, Object> graph = RuntimeGraph.normalizeRuntimeGraph(
            Map.of("nodes", List.of(Map.of("id", "1")), "edges", List.of()));

        // 4. Replay equivalence
        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"));
    }
}

import io.webweavex.kernel.RuntimeKernel;
import io.webweavex.kernel.UniversalInput;
import java.util.Map;

UniversalInput input = UniversalInput.of("https://example.com")
        .sourceType("web")
        .tick(0L)
        .build();

RuntimeKernel kernel = RuntimeKernel.getRuntimeKernel("web");
Map<String, Object> result = kernel.runPipeline(input.toDict(), 0L);

git clone -b java https://github.com/ni-sh-a-char/WebWeaveX.git
cd WebWeaveX/java
mvn clean install

mkdir -p libs
curl -L -o libs/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"))
}

git clone -b kotlin https://github.com/ni-sh-a-char/WebWeaveX.git
cd WebWeaveX/kotlin
./gradlew build

import io.webweavex.runtime.RuntimeKernel
import io.webweavex.runtime.UniversalInput
import io.webweavex.extract.ExtractionPipeline
import io.webweavex.fingerprint.Fingerprint
import io.webweavex.crypto.KaalkaV5

fun main() {
    // Runtime kernel — extract() returns a UniversalOutput
    val kernel = RuntimeKernel()
    val input  = UniversalInput("https://example.com")
    val output = kernel.extract(input)

    println("version:      ${kernel.version}")
    println("capabilities: ${kernel.capabilities}")

    // Deterministic fingerprint, byte-exact with Python/JS/Dart
    println("fingerprint:  ${Fingerprint.compute(input.toMap())}")

    // Direct text extraction
    val result = ExtractionPipeline.extractText(htmlString, "html")
}