conservation-enforcer 0.1.0__py3-none-any.whl

conservation_enforcer/__init__.py

@@ -0,0 +1,46 @@
+"""Conservation Enforcer — FLUX bytecode governance for LLM outputs.
+
+Implements conservation-law enforcement on AI behavior using deterministic
+FLUX bytecode programs as policy layers.
+
+Architecture:
+    User Request → LLM Call → [FLUX Conservation Validator] → Response
+                                        ↓
+                                  If violation: return correction
+                                  If clean: return response
+
+The FLUX bytecode acts as a deterministic, auditable policy layer.
+You can't lie to bytecode — it doesn't have opinions, it just executes instructions.
+"""
+
+from .vm import VM, Op, Syscall, RegisterFile, Memory
+from .assembler import assemble
+from .enforcer import ConservationEnforcer, EnforcementResult, Violation
+from .policies import (
+    length_budget_policy,
+    repetition_policy,
+    category_policy,
+    combined_policy,
+    entropy_policy,
+)
+
+__version__ = "0.1.0"
+__author__ = "SuperInstance"
+__license__ = "MIT"
+
+__all__ = [
+    "VM",
+    "Op",
+    "Syscall",
+    "RegisterFile",
+    "Memory",
+    "assemble",
+    "ConservationEnforcer",
+    "EnforcementResult",
+    "Violation",
+    "length_budget_policy",
+    "repetition_policy",
+    "category_policy",
+    "combined_policy",
+    "entropy_policy",
+]

conservation_enforcer/assembler.py

@@ -0,0 +1,206 @@
+"""FLUX Assembler — human-readable assembly → bytecode.
+
+Single clean implementation. Two-pass with label resolution.
+
+Supported syntax:
+    ; line comments       # also comments
+    label:                ; label definition
+    MOVI R0, 42           ; D-format: reg + i16 immediate
+    IADD R0, R1, R2       ; E-format: three registers
+    MOV R0, R1            ; C-format: two registers
+    INC R0                ; B-format: one register
+    HALT                  ; A-format: no operands
+    CMP R0, R1            ; set flags from R0 - R1
+    JE  label             ; jump if equal (flag_zero)
+    JNE label             ; jump if not equal
+    JSGE label            ; jump if signed ≥ (after CMP/ISUB)
+    JSLT label            ; jump if signed <
+    JMP label             ; unconditional jump
+    SYSCALL               ; dispatch using R0
+
+Convenience aliases (multi-instruction expansions):
+    JGE Rd, Rs, label     → CMP Rd, Rs + JSGE label
+    JLT Rd, Rs, label     → CMP Rd, Rs + JSLT label
+    JGT Rd, Rs, label     → CMP Rd, Rs + JE skip + JSGE label
+    JLE Rd, Rs, label     → CMP Rd, Rs + JE label + JSLT label
+"""
+
+from __future__ import annotations
+
+import re
+from typing import Optional
+
+from .vm import Op, NUM_REGISTERS
+
+
+SIMPLE = {
+    'NOP': (Op.NOP, 'A'), 'HALT': (Op.HALT, 'A'), 'YIELD': (Op.YIELD, 'A'),
+    'DUP': (Op.DUP, 'A'), 'RET': (Op.RET, 'A'), 'SYSCALL': (Op.SYSCALL, 'A'),
+    'INC': (Op.INC, 'B'), 'DEC': (Op.DEC, 'B'),
+    'PUSH': (Op.PUSH, 'B'), 'POP': (Op.POP, 'B'),
+    'MOV': (Op.MOV, 'C'), 'LOAD': (Op.LOAD, 'C'), 'STORE': (Op.STORE, 'C'),
+    'NEG': (Op.INEG, 'C'), 'INEG': (Op.INEG, 'C'),
+    'NOT': (Op.INOT, 'C'), 'INOT': (Op.INOT, 'C'),
+    'CMP': (Op.CMP, 'C'),
+    'JMP': (Op.JMP, 'D'), 'JZ': (Op.JZ, 'D'), 'JNZ': (Op.JNZ, 'D'),
+    'CALL': (Op.CALL, 'D'), 'MOVI': (Op.MOVI, 'D'),
+    'JE': (Op.JE, 'D'), 'JNE': (Op.JNE, 'D'),
+    'JSGE': (Op.JSGE, 'D'), 'JSLT': (Op.JSLT, 'D'),
+    'ADD': (Op.IADD, 'E'), 'IADD': (Op.IADD, 'E'),
+    'SUB': (Op.ISUB, 'E'), 'ISUB': (Op.ISUB, 'E'),
+    'MUL': (Op.IMUL, 'E'), 'IMUL': (Op.IMUL, 'E'),
+    'DIV': (Op.IDIV, 'E'), 'IDIV': (Op.IDIV, 'E'),
+    'MOD': (Op.IMOD, 'E'), 'IMOD': (Op.IMOD, 'E'),
+    'AND': (Op.IAND, 'E'), 'IAND': (Op.IAND, 'E'),
+    'OR': (Op.IOR, 'E'), 'IOR': (Op.IOR, 'E'),
+    'XOR': (Op.IXOR, 'E'), 'IXOR': (Op.IXOR, 'E'),
+    'SHL': (Op.ISHL, 'E'), 'ISHL': (Op.ISHL, 'E'),
+    'SHR': (Op.ISHR, 'E'), 'ISHR': (Op.ISHR, 'E'),
+}
+
+FMT_SIZE = {'A': 1, 'B': 2, 'C': 3, 'D': 4, 'E': 4}
+PSEUDO = {'JGE', 'JLE', 'JGT', 'JLT'}
+
+
+class AssemblerError(Exception):
+    pass
+
+
+def assemble(source: str) -> bytes:
+    """Assemble FLUX source code to bytecode."""
+    raw: list[dict] = []
+    labels: dict[str, int] = {}  # label → instruction index
+
+    # ── Parse ──
+    for line_num, line in enumerate(source.split('\n'), 1):
+        text = line
+        for marker in (';', '#'):
+            idx = text.find(marker)
+            if idx >= 0:
+                text = text[:idx]
+        text = text.strip()
+        if not text:
+            continue
+
+        # Label?
+        m = re.match(r'^([A-Za-z_]\w*):\s*(.*)$', text)
+        if m:
+            label = m.group(1)
+            if label in labels:
+                raise AssemblerError(f"Duplicate label '{label}'")
+            labels[label] = len(raw)
+            text = m.group(2).strip()
+            if not text:
+                continue
+
+        # Parse mnemonic
+        parts = text.split(None, 1)
+        mnem = parts[0].upper()
+        rest = parts[1].strip() if len(parts) > 1 else ""
+
+        def reg(tok: str) -> int:
+            tok = tok.strip().upper()
+            if not re.match(r'^R\d+$', tok):
+                raise AssemblerError(f"Line {line_num}: expected register, got '{tok}'")
+            n = int(tok[1:])
+            if n >= NUM_REGISTERS:
+                raise AssemblerError(f"Line {line_num}: R{n} out of range")
+            return n
+
+        if mnem in PSEUDO:
+            ps = [p.strip() for p in rest.split(',')]
+            if len(ps) != 3:
+                raise AssemblerError(f"Line {line_num}: {mnem} needs Rd, Rs, label")
+            rd, rs = reg(ps[0]), reg(ps[1])
+            lbl = ps[2]
+
+            # CMP rd, rs (3 bytes)
+            raw.append({'op': Op.CMP, 'fmt': 'C', 'rd': rd, 'rs': rs, 'size': 3})
+
+            if mnem == 'JGE':
+                raw.append({'op': Op.JSGE, 'fmt': 'D', 'label': lbl, 'size': 4})
+            elif mnem == 'JLT':
+                raw.append({'op': Op.JSLT, 'fmt': 'D', 'label': lbl, 'size': 4})
+            elif mnem == 'JLE':
+                raw.append({'op': Op.JE, 'fmt': 'D', 'label': lbl, 'size': 4})
+                raw.append({'op': Op.JSLT, 'fmt': 'D', 'label': lbl, 'size': 4})
+            elif mnem == 'JGT':
+                # JE skip (skip the next JSGE instruction if equal)
+                raw.append({'op': Op.JE, 'fmt': 'D', 'imm': 4, 'size': 4})
+                raw.append({'op': Op.JSGE, 'fmt': 'D', 'label': lbl, 'size': 4})
+
+        elif mnem in SIMPLE:
+            op, fmt = SIMPLE[mnem]
+            entry = {'op': op, 'fmt': fmt, 'size': FMT_SIZE[fmt]}
+
+            if fmt == 'A':
+                pass
+            elif fmt == 'B':
+                entry['rd'] = reg(rest)
+            elif fmt == 'C':
+                ps = [p.strip() for p in rest.split(',')]
+                entry['rd'] = reg(ps[0])
+                entry['rs'] = reg(ps[1])
+            elif fmt == 'D':
+                ps = [p.strip() for p in rest.split(',')]
+                if len(ps) == 1:
+                    entry['label'] = ps[0]
+                elif len(ps) == 2:
+                    entry['rd'] = reg(ps[0])
+                    v = ps[1]
+                    if v and (v[0].isdigit() or (v[0] == '-' and len(v) > 1)):
+                        entry['imm'] = int(v)
+                    else:
+                        entry['label'] = v
+            elif fmt == 'E':
+                ps = [p.strip() for p in rest.split(',')]
+                entry['rd'] = reg(ps[0])
+                entry['rs1'] = reg(ps[1])
+                entry['rs2'] = reg(ps[2])
+
+            raw.append(entry)
+        else:
+            raise AssemblerError(f"Line {line_num}: unknown instruction '{mnem}'")
+
+    # ── Compute byte offsets ──
+    offset = 0
+    for instr in raw:
+        instr['offset'] = offset
+        offset += instr['size']
+
+    # Build label → byte-offset map
+    label_bytes: dict[str, int] = {}
+    for lbl, idx in labels.items():
+        label_bytes[lbl] = raw[idx]['offset'] if idx < len(raw) else offset
+
+    # ── Emit ──
+    out = bytearray()
+    for instr in raw:
+        fmt = instr['fmt']
+        out.append(int(instr['op']))
+
+        if fmt == 'A':
+            pass
+        elif fmt == 'B':
+            out.append(instr['rd'])
+        elif fmt == 'C':
+            out.append(instr['rd'])
+            out.append(instr['rs'])
+        elif fmt == 'D':
+            out.append(instr.get('rd', 0))
+            if 'label' in instr:
+                if instr['label'] not in label_bytes:
+                    raise AssemblerError(f"Undefined label: '{instr['label']}'")
+                rel = label_bytes[instr['label']] - (instr['offset'] + 4)
+                out.append(rel & 0xFF)
+                out.append((rel >> 8) & 0xFF)
+            else:
+                imm = instr.get('imm', 0)
+                out.append(imm & 0xFF)
+                out.append((imm >> 8) & 0xFF)
+        elif fmt == 'E':
+            out.append(instr['rd'])
+            out.append(instr['rs1'])
+            out.append(instr['rs2'])
+
+    return bytes(out)

conservation_enforcer/enforcer.py

@@ -0,0 +1,100 @@
+"""ConservationEnforcer — the main enforcement class.
+
+Wraps any LLM call in a conservation-law check powered by FLUX bytecode.
+
+Usage:
+    from conservation_enforcer import ConservationEnforcer, length_budget_policy
+
+    enforcer = ConservationEnforcer(length_budget_policy(max_tokens=500), budget=500)
+    result = enforcer.enforce("What is AI?", llm_response)
+
+    if result.allowed:
+        return result.output
+    else:
+        return result.correction
+"""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+from typing import Callable, Optional
+
+from .vm import VM
+
+
+@dataclass
+class Violation:
+    reason: str
+    code: int
+
+
+@dataclass
+class EnforcementResult:
+    allowed: bool
+    output: str
+    violation: Optional[Violation] = None
+    cycles: int = 0
+
+    def __bool__(self) -> bool:
+        return self.allowed
+
+
+class ConservationEnforcer:
+    """Enforce conservation laws on LLM outputs using FLUX bytecode.
+
+    The bytecode policy is deterministic and auditable. It runs in a
+    sandboxed VM and cannot be influenced by the LLM output it checks.
+
+    Convention: R0 = 0 at HALT means ALLOW. R0 ≠ 0 means BLOCK.
+    The policy sets R1 and calls SET_VIOLATION (syscall 8) to record the reason.
+    """
+
+    def __init__(
+        self,
+        policy_bytecode: bytes,
+        budget: int = 1000,
+        correction_template: str = (
+            "⚠️ This response was blocked by a conservation law: {reason}. "
+            "Please try again with a more conserved response."
+        ),
+    ):
+        self.vm = VM()
+        self.policy = policy_bytecode
+        self.budget = budget
+        self.correction_template = correction_template
+
+    def enforce(self, input_text: str, output_text: str) -> EnforcementResult:
+        """Check an LLM output against conservation laws."""
+        self.vm.load_input(input_text)
+        self.vm.load_output(output_text)
+        self.vm.set_budget(self.budget)
+
+        result_code = self.vm.run(self.policy)  # 0 = allow, non-zero = block
+
+        if result_code == 0:
+            return EnforcementResult(
+                allowed=True,
+                output=output_text,
+                cycles=self.vm.cycle_count,
+            )
+        else:
+            violation = Violation(
+                reason=self.vm.violation_reason or "Unknown conservation violation",
+                code=result_code,
+            )
+            correction = self.correction_template.format(reason=violation.reason)
+            return EnforcementResult(
+                allowed=False,
+                output=correction,
+                violation=violation,
+                cycles=self.vm.cycle_count,
+            )
+
+    def enforce_with_llm(
+        self,
+        input_text: str,
+        llm_call: Callable[[str], str],
+    ) -> EnforcementResult:
+        """Call the LLM and enforce in one step."""
+        output = llm_call(input_text)
+        return self.enforce(input_text, output)

conservation_enforcer/policies/__init__.py

@@ -0,0 +1,228 @@
+"""Pre-built conservation policies written in FLUX assembly.
+
+Available policies:
+    - length_budget_policy:  Block outputs exceeding a token budget
+    - repetition_policy:     Block outputs with excessive repetition
+    - category_policy:       Block outputs that drift off-topic
+    - entropy_policy:        Block outputs with too-low entropy
+    - combined_policy:       Multiple conservation laws in one program
+
+Policy convention:
+    - R0 = 0 at HALT → ALLOW
+    - R0 ≠ 0 at HALT → BLOCK
+    - Syscall number goes in R0, args in R1-R7
+    - SET_VIOLATION (syscall 8) reads R1 for the reason code
+"""
+
+from __future__ import annotations
+
+from ..assembler import assemble
+
+
+def length_budget_policy(max_tokens: int = 500) -> bytes:
+    """Enforce a maximum output length (approximate token count).
+
+    Conservation law: Information output cannot exceed the budget.
+    """
+    source = f"""
+    ; ── Length Budget Conservation Law ──
+    ; R0 = result (0=allow, non-zero=block)
+
+    MOVI R0, 0          ; default: ALLOW
+    MOVI R0, 5          ; syscall: GET_TOKEN_COUNT
+    SYSCALL
+    MOV  R2, R0         ; R2 = token_count (return value clobbers R0)
+
+    MOVI R0, 10         ; syscall: GET_BUDGET
+    SYSCALL
+    MOV  R3, R0         ; R3 = budget
+
+    ; if token_count > budget → block
+    JGT  R2, R3, block
+
+    MOVI R0, 0          ; ALLOW
+    HALT
+
+block:
+    MOVI R1, 1          ; reason code: LENGTH_BUDGET
+    MOVI R0, 8          ; syscall: SET_VIOLATION
+    SYSCALL
+    MOVI R0, 1          ; BLOCK
+    HALT
+    """
+    return assemble(source)
+
+
+def repetition_policy(max_ratio: int = 300) -> bytes:
+    """Block outputs where a single word appears too frequently.
+
+    max_ratio is in per-mille (300 = 30%).
+    Conservation law: Information diversity.
+    """
+    source = f"""
+    ; ── Repetition Conservation Law ──
+
+    MOVI R0, 6          ; syscall: GET_REPETITION
+    SYSCALL
+    MOV  R2, R0         ; R2 = repetition ratio
+
+    MOVI R3, {max_ratio}    ; threshold
+
+    JGT  R2, R3, block  ; if repetition > threshold → block
+
+    MOVI R0, 0          ; ALLOW
+    HALT
+
+block:
+    MOVI R1, 2          ; reason: REPETITION
+    MOVI R0, 8          ; SET_VIOLATION
+    SYSCALL
+    MOVI R0, 1          ; BLOCK
+    HALT
+    """
+    return assemble(source)
+
+
+def category_policy(min_overlap: int = 150) -> bytes:
+    """Block outputs that drift too far from the input topic.
+
+    min_overlap is in per-mille (150 = 15%).
+    Conservation law: Category confinement.
+    """
+    source = f"""
+    ; ── Category Confinement Conservation Law ──
+
+    MOVI R0, 7          ; syscall: GET_CATEGORY
+    SYSCALL
+    MOV  R2, R0         ; R2 = overlap score
+
+    MOVI R3, {min_overlap}   ; minimum required overlap
+
+    JLT  R2, R3, block  ; if overlap < threshold → block
+
+    MOVI R0, 0          ; ALLOW
+    HALT
+
+block:
+    MOVI R1, 3          ; reason: CATEGORY
+    MOVI R0, 8          ; SET_VIOLATION
+    SYSCALL
+    MOVI R0, 1          ; BLOCK
+    HALT
+    """
+    return assemble(source)
+
+
+def entropy_policy(min_entropy: int = 2000) -> bytes:
+    """Block outputs with too-low Shannon entropy.
+
+    min_entropy is entropy × 1000 (2000 = 2.0 bits/word minimum).
+    Conservation law: Information density.
+    """
+    source = f"""
+    ; ── Entropy Conservation Law ──
+
+    MOVI R0, 12         ; syscall: GET_ENTROPY
+    SYSCALL
+    MOV  R2, R0         ; R2 = entropy × 1000
+
+    MOVI R3, {min_entropy}   ; minimum entropy
+
+    JLT  R2, R3, block  ; if entropy < threshold → block
+
+    MOVI R0, 0          ; ALLOW
+    HALT
+
+block:
+    MOVI R1, 4          ; reason: ENTROPY
+    MOVI R0, 8          ; SET_VIOLATION
+    SYSCALL
+    MOVI R0, 1          ; BLOCK
+    HALT
+    """
+    return assemble(source)
+
+
+def combined_policy(
+    max_tokens: int = 500,
+    max_repetition: int = 300,
+    min_overlap: int = 100,
+    min_entropy: int = 1500,
+) -> bytes:
+    """Combined conservation policy: length + repetition + category + entropy.
+
+    This is the flagship policy — four conservation laws in one bytecode program.
+    """
+    source = f"""
+    ; ═══════════════════════════════════════════════════════
+    ; COMBINED CONSERVATION POLICY
+    ;   1. Length budget     (information quantity)
+    ;   2. Repetition limit  (information diversity)
+    ;   3. Category confinement (topical coherence)
+    ;   4. Entropy floor     (information density)
+    ; ═══════════════════════════════════════════════════════
+
+    ; ── Law 1: Length Budget ──
+    MOVI R0, 5              ; GET_TOKEN_COUNT
+    SYSCALL
+    MOV  R2, R0
+    MOVI R0, 10             ; GET_BUDGET
+    SYSCALL
+    MOV  R3, R0
+    JGT  R2, R3, block_length
+
+    ; ── Law 2: Repetition Limit ──
+    MOVI R0, 6              ; GET_REPETITION
+    SYSCALL
+    MOV  R2, R0
+    MOVI R3, {max_repetition}
+    JGT  R2, R3, block_repetition
+
+    ; ── Law 3: Category Confinement ──
+    MOVI R0, 7              ; GET_CATEGORY
+    SYSCALL
+    MOV  R2, R0
+    MOVI R3, {min_overlap}
+    JLT  R2, R3, block_category
+
+    ; ── Law 4: Entropy Floor ──
+    MOVI R0, 12             ; GET_ENTROPY
+    SYSCALL
+    MOV  R2, R0
+    MOVI R3, {min_entropy}
+    JLT  R2, R3, block_entropy
+
+    ; ── All laws satisfied ──
+    MOVI R0, 0              ; ALLOW
+    HALT
+
+    ; ── Violation handlers ──
+block_length:
+    MOVI R1, 1              ; reason: LENGTH
+    MOVI R0, 8              ; SET_VIOLATION
+    SYSCALL
+    MOVI R0, 1              ; BLOCK
+    HALT
+
+block_repetition:
+    MOVI R1, 2              ; reason: REPETITION
+    MOVI R0, 8
+    SYSCALL
+    MOVI R0, 1
+    HALT
+
+block_category:
+    MOVI R1, 3              ; reason: CATEGORY
+    MOVI R0, 8
+    SYSCALL
+    MOVI R0, 1
+    HALT
+
+block_entropy:
+    MOVI R1, 4              ; reason: ENTROPY
+    MOVI R0, 8
+    SYSCALL
+    MOVI R0, 1
+    HALT
+    """
+    return assemble(source)

conservation_enforcer/vm.py

@@ -0,0 +1,412 @@
+"""FLUX Micro-VM — Register-based bytecode interpreter.
+
+Implements the core FLUX ISA for conservation-law enforcement.
+Based on the FLUX Bytecode Specification (SuperInstance/flux-core).
+
+This is a deterministic, side-effect-free VM. It cannot lie — it executes
+instructions and produces a result. That determinism is the whole point.
+
+Instruction Formats:
+    A (1 byte):  [opcode]
+    B (2 bytes): [opcode][reg:u8]
+    C (3 bytes): [opcode][rd:u8][rs:u8]
+    D (4 bytes): [opcode][reg:u8][off_lo:u8][off_hi:u8]  (signed i16 offset)
+    E (4 bytes): [opcode][rd:u8][rs1:u8][rs2:u8]
+"""
+
+from __future__ import annotations
+
+import struct
+import math
+from dataclasses import dataclass, field
+from enum import IntEnum
+from collections import Counter
+from typing import Callable
+
+
+# ── Opcodes ────────────────────────────────────────────────────────────────
+
+class Op(IntEnum):
+    NOP   = 0x00
+    MOV   = 0x01
+    LOAD  = 0x02
+    STORE = 0x03
+    JMP   = 0x04
+    JZ    = 0x05
+    JNZ   = 0x06
+    CALL  = 0x07
+    IADD  = 0x08
+    ISUB  = 0x09
+    IMUL  = 0x0A
+    IDIV  = 0x0B
+    IMOD  = 0x0C
+    INEG  = 0x0D
+    INC   = 0x0E
+    DEC   = 0x0F
+    IAND  = 0x10
+    IOR   = 0x11
+    IXOR  = 0x12
+    INOT  = 0x13
+    ISHL  = 0x14
+    ISHR  = 0x15
+    PUSH  = 0x20
+    POP   = 0x21
+    DUP   = 0x22
+    RET   = 0x28
+    MOVI  = 0x2B
+    CMP   = 0x2D
+    JE    = 0x2E
+    JNE   = 0x2F
+    # Sign-flag jumps (for signed comparisons after CMP/ISUB)
+    JSGE  = 0x30   # jump if !flag_sign (signed ≥)
+    JSLT  = 0x31   # jump if flag_sign (signed <)
+    HALT  = 0x80
+    YIELD = 0x81
+    SYSCALL = 0xF0
+
+
+# ── Exceptions ─────────────────────────────────────────────────────────────
+
+class VMError(Exception): pass
+class VMHalt(VMError): pass
+class VMDivisionByZero(VMError): pass
+class VMInvalidOpcode(VMError): pass
+
+
+# ── Register File ──────────────────────────────────────────────────────────
+
+NUM_REGISTERS = 16
+
+@dataclass
+class RegisterFile:
+    """R0–R15 general-purpose registers + condition flags."""
+    r: list[int] = field(default_factory=lambda: [0] * NUM_REGISTERS)
+    flag_zero: bool = False
+    flag_sign: bool = False
+
+    def get(self, idx: int) -> int:
+        return self.r[idx]
+
+    def set(self, idx: int, val: int) -> None:
+        self.r[idx] = val & 0xFFFFFFFF
+        self._update_flags(self.r[idx])
+
+    def _update_flags(self, uval: int) -> None:
+        self.flag_zero = (uval & 0xFFFFFFFF) == 0
+        signed = uval if uval < 0x80000000 else uval - 0x100000000
+        self.flag_sign = signed < 0
+
+
+# ── Memory ─────────────────────────────────────────────────────────────────
+
+class Memory:
+    def __init__(self, size: int = 65536):
+        self.buf = bytearray(size)
+
+    def store_i32(self, addr: int, val: int) -> None:
+        if addr + 4 <= len(self.buf):
+            struct.pack_into('<i', self.buf, addr, val & 0x7FFFFFFF if val < 0x80000000 else val)
+
+    def load_i32(self, addr: int) -> int:
+        return struct.unpack_from('<i', self.buf, addr)[0]
+
+    def store_bytes(self, addr: int, data: bytes) -> None:
+        end = min(addr + len(data), len(self.buf))
+        self.buf[addr:end] = data[:end - addr]
+
+    def load_bytes(self, addr: int, length: int) -> bytes:
+        return bytes(self.buf[addr:addr + length])
+
+
+# ── Syscall Numbers ────────────────────────────────────────────────────────
+
+class Syscall(IntEnum):
+    GET_INPUT_LEN     = 1
+    GET_OUTPUT_LEN    = 2
+    GET_INPUT_WORDS   = 3
+    GET_OUTPUT_WORDS  = 4
+    GET_TOKEN_COUNT   = 5
+    GET_REPETITION    = 6
+    GET_CATEGORY      = 7
+    SET_VIOLATION     = 8    # R1 = reason code
+    GET_BUDGET        = 10
+    GET_UNIQUE_RATIO  = 11
+    GET_ENTROPY       = 12
+
+
+VIOLATION_REASONS = {
+    1: "Length budget exceeded",
+    2: "Excessive repetition detected",
+    3: "Category confinement violation",
+    4: "Information entropy violation",
+    99: "Custom conservation law violation",
+}
+
+
+# ── VM ─────────────────────────────────────────────────────────────────────
+
+class VM:
+    """FLUX Virtual Machine — deterministic bytecode interpreter.
+
+    Usage:
+        vm = VM()
+        vm.load_input("user question")
+        vm.load_output("LLM response")
+        vm.set_budget(500)
+        vm.run(bytecode)
+        # R0 at HALT = result: 0 = allow, non-zero = block
+    """
+
+    MAX_CYCLES = 1_000_000
+
+    def __init__(self, memory_size: int = 65536):
+        self.regs = RegisterFile()
+        self.memory = Memory(memory_size)
+        self.pc = 0
+        self.bytecode = b''
+        self.running = False
+        self.cycle_count = 0
+        self._input_text = ""
+        self._output_text = ""
+        self._budget = 1000
+        self._violated = False
+        self._violation_reason = ""
+        self._stack: list[int] = []
+
+    @property
+    def violated(self) -> bool:
+        return self._violated
+
+    @property
+    def violation_reason(self) -> str:
+        return self._violation_reason
+
+    def load_input(self, text: str) -> None:
+        self._input_text = text
+
+    def load_output(self, text: str) -> None:
+        self._output_text = text
+
+    def set_budget(self, budget: int) -> None:
+        self._budget = budget
+
+    def reset(self) -> None:
+        self.regs = RegisterFile()
+        self.pc = 0
+        self.cycle_count = 0
+        self.running = False
+        self._violated = False
+        self._violation_reason = ""
+        self._stack.clear()
+
+    def run(self, bytecode: bytes) -> int:
+        """Execute bytecode. Returns R0 at HALT (0=allow, non-zero=block)."""
+        self.bytecode = bytecode
+        self.reset()
+        try:
+            while self.cycle_count < self.MAX_CYCLES:
+                if self.pc >= len(self.bytecode):
+                    break
+                self._step()
+                self.cycle_count += 1
+        except VMHalt:
+            pass
+        if self.cycle_count >= self.MAX_CYCLES:
+            raise VMError(f"Cycle budget exhausted ({self.MAX_CYCLES})")
+        return self.regs.get(0)
+
+    def _step(self) -> None:
+        opcode = self.bytecode[self.pc]
+        try:
+            op = Op(opcode)
+        except ValueError:
+            raise VMInvalidOpcode(f"0x{opcode:02X} at pc={self.pc}")
+        handler = self._DISPATCH.get(op)
+        if handler is None:
+            raise VMInvalidOpcode(f"Unhandled 0x{opcode:02X} at pc={self.pc}")
+        handler(self)
+
+    # ── Decoders ──
+
+    def _d_A(self): self.pc += 1
+    def _d_B(self) -> int:
+        r = self.bytecode[self.pc + 1]; self.pc += 2; return r
+    def _d_C(self) -> tuple[int, int]:
+        rd = self.bytecode[self.pc + 1]; rs = self.bytecode[self.pc + 2]; self.pc += 3; return rd, rs
+    def _d_D(self) -> tuple[int, int]:
+        reg = self.bytecode[self.pc + 1]
+        lo = self.bytecode[self.pc + 2]; hi = self.bytecode[self.pc + 3]
+        off = lo | (hi << 8)
+        if off >= 0x8000: off -= 0x10000
+        self.pc += 4; return reg, off
+    def _d_E(self) -> tuple[int, int, int]:
+        rd = self.bytecode[self.pc + 1]; rs1 = self.bytecode[self.pc + 2]; rs2 = self.bytecode[self.pc + 3]
+        self.pc += 4; return rd, rs1, rs2
+
+    # ── Handlers ──
+
+    def _h_nop(self): self._d_A()
+    def _h_mov(self):
+        rd, rs = self._d_C(); self.regs.set(rd, self.regs.get(rs))
+    def _h_load(self):
+        rd, rs = self._d_C(); self.regs.set(rd, self.memory.load_i32(self.regs.get(rs)))
+    def _h_store(self):
+        rd, rs = self._d_C(); self.memory.store_i32(self.regs.get(rs), self.regs.get(rd))
+    def _h_jmp(self):
+        _, off = self._d_D(); self.pc += off
+    def _h_jz(self):
+        reg, off = self._d_D()
+        if self.regs.get(reg) == 0: self.pc += off
+    def _h_jnz(self):
+        reg, off = self._d_D()
+        if self.regs.get(reg) != 0: self.pc += off
+    def _h_call(self):
+        reg, off = self._d_D(); self._stack.append(self.pc); self.pc += off
+    def _h_iadd(self):
+        rd, rs1, rs2 = self._d_E(); self.regs.set(rd, self.regs.get(rs1) + self.regs.get(rs2))
+    def _h_isub(self):
+        rd, rs1, rs2 = self._d_E(); self.regs.set(rd, self.regs.get(rs1) - self.regs.get(rs2))
+    def _h_imul(self):
+        rd, rs1, rs2 = self._d_E(); self.regs.set(rd, self.regs.get(rs1) * self.regs.get(rs2))
+    def _h_idiv(self):
+        rd, rs1, rs2 = self._d_E()
+        d = self.regs.get(rs2)
+        if d == 0: raise VMDivisionByZero(f"pc={self.pc}")
+        self.regs.set(rd, self.regs.get(rs1) // d)
+    def _h_imod(self):
+        rd, rs1, rs2 = self._d_E()
+        d = self.regs.get(rs2)
+        if d == 0: raise VMDivisionByZero(f"pc={self.pc}")
+        self.regs.set(rd, self.regs.get(rs1) % d)
+    def _h_ineg(self):
+        rd, rs = self._d_C(); self.regs.set(rd, (-self.regs.get(rs)) & 0xFFFFFFFF)
+    def _h_inc(self):
+        reg = self._d_B(); self.regs.set(reg, self.regs.get(reg) + 1)
+    def _h_dec(self):
+        reg = self._d_B(); self.regs.set(reg, self.regs.get(reg) - 1)
+    def _h_iand(self):
+        rd, rs1, rs2 = self._d_E(); self.regs.set(rd, self.regs.get(rs1) & self.regs.get(rs2))
+    def _h_ior(self):
+        rd, rs1, rs2 = self._d_E(); self.regs.set(rd, self.regs.get(rs1) | self.regs.get(rs2))
+    def _h_ixor(self):
+        rd, rs1, rs2 = self._d_E(); self.regs.set(rd, self.regs.get(rs1) ^ self.regs.get(rs2))
+    def _h_inot(self):
+        rd, rs = self._d_C(); self.regs.set(rd, (~self.regs.get(rs)) & 0xFFFFFFFF)
+    def _h_ishl(self):
+        rd, rs1, rs2 = self._d_E(); self.regs.set(rd, self.regs.get(rs1) << self.regs.get(rs2))
+    def _h_ishr(self):
+        rd, rs1, rs2 = self._d_E(); self.regs.set(rd, self.regs.get(rs1) >> self.regs.get(rs2))
+    def _h_push(self):
+        reg = self._d_B(); self._stack.append(self.regs.get(reg))
+    def _h_pop(self):
+        reg = self._d_B(); self.regs.set(reg, self._stack.pop() if self._stack else 0)
+    def _h_dup(self):
+        self._d_A()
+        if self._stack: self._stack.append(self._stack[-1])
+    def _h_ret(self):
+        self._d_A()
+        if self._stack: self.pc = self._stack.pop()
+        else: self.running = False
+    def _h_movi(self):
+        reg, off = self._d_D()
+        # Store as signed value wrapped to 32-bit unsigned
+        self.regs.set(reg, off & 0xFFFF)
+    def _h_cmp(self):
+        rd, rs = self._d_C()
+        a = self.regs.get(rd); b = self.regs.get(rs)
+        diff = (a - b) & 0xFFFFFFFF
+        self.regs.flag_zero = diff == 0
+        signed = diff if diff < 0x80000000 else diff - 0x100000000
+        self.regs.flag_sign = signed < 0
+    def _h_je(self):
+        _, off = self._d_D()
+        if self.regs.flag_zero: self.pc += off
+    def _h_jne(self):
+        _, off = self._d_D()
+        if not self.regs.flag_zero: self.pc += off
+    def _h_jsge(self):
+        _, off = self._d_D()
+        if not self.regs.flag_sign: self.pc += off
+    def _h_jslt(self):
+        _, off = self._d_D()
+        if self.regs.flag_sign: self.pc += off
+    def _h_syscall(self):
+        self._d_A()
+        num = self.regs.get(0)
+        handler = self._SYSCALLS.get(num)
+        if handler: handler(self)
+    def _h_halt(self):
+        self._d_A(); self.running = False; raise VMHalt("HALT instruction")
+    def _h_yield(self):
+        self._d_A()
+
+    # ── Dispatch table ──
+    _DISPATCH: dict[Op, Callable] = {}
+
+
+# ── Syscall implementations ────────────────────────────────────────────────
+
+def _sys_input_len(vm: VM): vm.regs.set(0, len(vm._input_text))
+def _sys_output_len(vm: VM): vm.regs.set(0, len(vm._output_text))
+def _sys_input_words(vm: VM): vm.regs.set(0, len(vm._input_text.split()))
+def _sys_output_words(vm: VM): vm.regs.set(0, len(vm._output_text.split()))
+def _sys_token_count(vm: VM): vm.regs.set(0, max(1, len(vm._output_text) // 4))
+def _sys_repetition(vm: VM):
+    words = vm._output_text.lower().split()
+    if not words: vm.regs.set(0, 0); return
+    counts = Counter(words)
+    mx = counts.most_common(1)[0][1]
+    vm.regs.set(0, (mx * 1000) // len(words))
+def _sys_category(vm: VM):
+    iw = set(vm._input_text.lower().split()); ow = set(vm._output_text.lower().split())
+    if not ow: vm.regs.set(0, 0); return
+    ov = len(iw & ow)
+    vm.regs.set(0, min(1000, (ov * 1000) // len(ow)))
+def _sys_set_violation(vm: VM):
+    vm._violated = True
+    code = vm.regs.get(1)
+    vm._violation_reason = VIOLATION_REASONS.get(code, f"Violation code {code}")
+def _sys_get_budget(vm: VM): vm.regs.set(0, vm._budget)
+def _sys_unique_ratio(vm: VM):
+    words = vm._output_text.lower().split()
+    if not words: vm.regs.set(0, 1000); return
+    vm.regs.set(0, (len(set(words)) * 1000) // len(words))
+def _sys_entropy(vm: VM):
+    words = vm._output_text.lower().split()
+    if not words: vm.regs.set(0, 0); return
+    total = len(words); ent = 0.0
+    for c in Counter(words).values():
+        p = c / total; ent -= p * math.log2(p)
+    vm.regs.set(0, int(ent * 1000))
+
+
+# ── Build dispatch + syscall tables ────────────────────────────────────────
+
+VM._DISPATCH = {
+    Op.NOP: VM._h_nop, Op.MOV: VM._h_mov, Op.LOAD: VM._h_load,
+    Op.STORE: VM._h_store, Op.JMP: VM._h_jmp, Op.JZ: VM._h_jz,
+    Op.JNZ: VM._h_jnz, Op.CALL: VM._h_call, Op.IADD: VM._h_iadd,
+    Op.ISUB: VM._h_isub, Op.IMUL: VM._h_imul, Op.IDIV: VM._h_idiv,
+    Op.IMOD: VM._h_imod, Op.INEG: VM._h_ineg, Op.INC: VM._h_inc,
+    Op.DEC: VM._h_dec, Op.IAND: VM._h_iand, Op.IOR: VM._h_ior,
+    Op.IXOR: VM._h_ixor, Op.INOT: VM._h_inot, Op.ISHL: VM._h_ishl,
+    Op.ISHR: VM._h_ishr, Op.PUSH: VM._h_push, Op.POP: VM._h_pop,
+    Op.DUP: VM._h_dup, Op.RET: VM._h_ret, Op.MOVI: VM._h_movi,
+    Op.CMP: VM._h_cmp, Op.JE: VM._h_je, Op.JNE: VM._h_jne,
+    Op.JSGE: VM._h_jsge, Op.JSLT: VM._h_jslt,
+    Op.SYSCALL: VM._h_syscall, Op.HALT: VM._h_halt, Op.YIELD: VM._h_yield,
+}
+
+VM._SYSCALLS = {
+    int(Syscall.GET_INPUT_LEN): _sys_input_len,
+    int(Syscall.GET_OUTPUT_LEN): _sys_output_len,
+    int(Syscall.GET_INPUT_WORDS): _sys_input_words,
+    int(Syscall.GET_OUTPUT_WORDS): _sys_output_words,
+    int(Syscall.GET_TOKEN_COUNT): _sys_token_count,
+    int(Syscall.GET_REPETITION): _sys_repetition,
+    int(Syscall.GET_CATEGORY): _sys_category,
+    int(Syscall.SET_VIOLATION): _sys_set_violation,
+    int(Syscall.GET_BUDGET): _sys_get_budget,
+    int(Syscall.GET_UNIQUE_RATIO): _sys_unique_ratio,
+    int(Syscall.GET_ENTROPY): _sys_entropy,
+}

conservation_enforcer-0.1.0.dist-info/METADATA

@@ -0,0 +1,227 @@
+Metadata-Version: 2.4
+Name: conservation-enforcer
+Version: 0.1.0
+Summary: FLUX bytecode conservation-law enforcement for LLM outputs
+Author: SuperInstance
+License: MIT
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Provides-Extra: dev
+Requires-Dist: pytest>=7.0; extra == "dev"
+Dynamic: license-file
+
+# ⚡ Conservation Enforcer
+
+**FLUX bytecode conservation-law enforcement for LLM outputs.**
+
+This is a working prototype that demonstrates conservation-law governance on AI behavior. It wraps any LLM call in a deterministic, auditable policy layer implemented as FLUX bytecode.
+
+```
+User Request → LLM Call → [FLUX Conservation Validator] → Response
+                                    ↓
+                              If violation: return correction
+                              If clean: return response
+```
+
+The FLUX bytecode acts as a deterministic, auditable policy layer. **You can't lie to bytecode** — it doesn't have opinions, it just executes instructions.
+
+## Why This Matters
+
+Current AI alignment approaches rely on:
+- **Prompt engineering** (the LLM can ignore instructions)
+- **RLHF tuning** (opaque, hard to verify)
+- **Output filtering** (post-hoc, not deterministic)
+
+Conservation enforcement is different:
+- **Deterministic**: Same input always produces the same decision
+- **Auditable**: Every byte of policy can be inspected and verified
+- **Immune to manipulation**: Bytecode has no opinions to argue with
+- **Composable**: Multiple conservation laws combine into one program
+- **Portable**: FLUX bytecode runs on Python, Rust, and JS VMs
+
+Conservation laws are the foundation of physics. Noether's theorem connects symmetries to conservation laws. This project brings that same mathematical rigor to AI governance.
+
+## Installation
+
+```bash
+pip install -e .
+```
+
+## Quick Start
+
+```python
+from conservation_enforcer import ConservationEnforcer, combined_policy
+
+# Create a combined policy: length + repetition + category + entropy
+policy = combined_policy(
+    max_tokens=500,
+    max_repetition=300,
+    min_overlap=100,
+    min_entropy=1500,
+)
+
+enforcer = ConservationEnforcer(policy, budget=500)
+
+# Check an LLM output
+result = enforcer.enforce(
+    input_text="What is machine learning?",
+    output_text="Machine learning is a subset of AI that learns from data.",
+)
+
+if result.allowed:
+    print(result.output)
+else:
+    print(f"Blocked: {result.violation.reason}")
+```
+
+## Conservation Laws
+
+### 1. Length Budget (Information Quantity)
+```python
+from conservation_enforcer import length_budget_policy
+
+policy = length_budget_policy(max_tokens=500)
+```
+The output cannot exceed the allocated information budget. This is analogous to energy conservation in physics — you can't output more information than you were allocated.
+
+### 2. Repetition Limit (Information Diversity)
+```python
+from conservation_enforcer import repetition_policy
+
+policy = repetition_policy(max_ratio=300)  # max 30% repetition
+```
+The output must maintain diversity. Degenerate repetition is the informational equivalent of thermal equilibrium — a system that repeats has exhausted its information capacity.
+
+### 3. Category Confinement (Topical Coherence)
+```python
+from conservation_enforcer import category_policy
+
+policy = category_policy(min_overlap=150)  # 15% word overlap required
+```
+The output must stay within the category/domain of the input. This prevents hallucinated content and topic drift — the output's "state" must remain in the same "potential well" as the input.
+
+### 4. Entropy Floor (Information Density)
+```python
+from conservation_enforcer import entropy_policy
+
+policy = entropy_policy(min_entropy=2000)  # 2.0 bits/word minimum
+```
+The output must have sufficient Shannon entropy. Low entropy means the output is too predictable and not carrying enough information.
+
+### Combined Policy (All Four Laws)
+```python
+from conservation_enforcer import combined_policy
+
+policy = combined_policy(
+    max_tokens=500,
+    max_repetition=300,
+    min_overlap=100,
+    min_entropy=1500,
+)
+```
+
+## Writing Custom Policies
+
+Policies are written in FLUX assembly:
+
+```flux
+; Custom policy: block outputs longer than 100 tokens
+MOVI R0, 5          ; syscall: GET_TOKEN_COUNT
+SYSCALL
+MOV  R2, R0         ; save token count
+
+MOVI R0, 10         ; syscall: GET_BUDGET
+SYSCALL
+MOV  R3, R0         ; save budget
+
+JGT  R2, R3, block  ; if tokens > budget → block
+
+MOVI R0, 0          ; ALLOW
+HALT
+
+block:
+MOVI R1, 1          ; reason: LENGTH_BUDGET
+MOVI R0, 8          ; syscall: SET_VIOLATION
+SYSCALL
+MOVI R0, 1          ; BLOCK
+HALT
+```
+
+Compile and use:
+```python
+from conservation_enforcer import assemble, ConservationEnforcer
+
+bytecode = assemble(source_code)
+enforcer = ConservationEnforcer(bytecode, budget=100)
+result = enforcer.enforce("question", "response")
+```
+
+## FLUX ISA
+
+The VM implements a register-based ISA with 16 registers (R0–R15):
+
+| Format | Layout | Example |
+|--------|--------|---------|
+| A | `[opcode]` | `HALT` |
+| B | `[opcode][reg]` | `INC R0` |
+| C | `[opcode][rd][rs]` | `CMP R0, R1` |
+| D | `[opcode][reg][off_lo][off_hi]` | `JE label` |
+| E | `[opcode][rd][rs1][rs2]` | `IADD R0, R1, R2` |
+
+Key instructions: `MOVI`, `MOV`, `IADD`, `ISUB`, `IMUL`, `IDIV`, `CMP`, `JE`, `JNE`, `JSGE`, `JSLT`, `SYSCALL`, `HALT`.
+
+Pseudo-instructions for convenience: `JGE`, `JGT`, `JLE`, `JLT`.
+
+### Syscalls
+
+| # | Name | Returns |
+|---|------|---------|
+| 1 | GET_INPUT_LEN | Length of input text |
+| 2 | GET_OUTPUT_LEN | Length of output text |
+| 5 | GET_TOKEN_COUNT | Approximate token count |
+| 6 | GET_REPETITION | Max word frequency ratio × 1000 |
+| 7 | GET_CATEGORY | Input/output word overlap × 1000 |
+| 8 | SET_VIOLATION | Sets violation flag (R1 = reason code) |
+| 10 | GET_BUDGET | Configured information budget |
+| 11 | GET_UNIQUE_RATIO | Unique/total words × 1000 |
+| 12 | GET_ENTROPY | Shannon entropy × 1000 |
+
+## Demonstration
+
+```bash
+python examples/demo.py
+```
+
+## Tests
+
+```bash
+python -m pytest tests/ -v
+```
+
+## Architecture
+
+```
+src/conservation_enforcer/
+├── __init__.py      Public API
+├── vm.py            FLUX VM (register-based bytecode interpreter)
+├── assembler.py     Two-pass FLUX assembler with label resolution
+├── enforcer.py      ConservationEnforcer class
+└── policies/
+    └── __init__.py  Pre-built conservation policies in FLUX assembly
+```
+
+## Related Projects
+
+- [flux-runtime](https://github.com/SuperInstance/flux-runtime) — Full FLUX runtime (Python)
+- [flux-core](https://github.com/SuperInstance/flux-core) — FLUX bytecode runtime (Rust)
+- [flux-js](https://github.com/SuperInstance/flux-js) — FLUX VM (JavaScript)
+- [conservation-law-rs](https://github.com/SuperInstance/conservation-law-rs) — Conservation laws for agent dynamics
+
+## License
+
+MIT
+
+---
+
+*This is not alignment theory. This is enforcement engineering.*

conservation_enforcer-0.1.0.dist-info/RECORD

@@ -0,0 +1,10 @@
+conservation_enforcer/__init__.py,sha256=dfdtu29KzzTEVQYmsCwMpasbzMQkLObzPBIvPOtTldg,1269
+conservation_enforcer/assembler.py,sha256=SegUwotLko1R658JuKn9TUVWTG5F8HuL9MnUnwtgF6A,7567
+conservation_enforcer/enforcer.py,sha256=i6U1VMYD-Fgi6xjO0gQf-_Yx7VLH0CyWr_dVZFkmBqE,2949
+conservation_enforcer/vm.py,sha256=pesIWA-EMC_gx2QS6V3F2qHQZ_3zw0PTxDcYppJn3JY,15191
+conservation_enforcer/policies/__init__.py,sha256=iXAqaT1srW4EKGNafLp2kH0g9WWrcP7WrtQy0uJQrxA,6102
+conservation_enforcer-0.1.0.dist-info/licenses/LICENSE,sha256=oIZ4iMwyoGNfEZRn_qZ2bqd1wzV8oUQgjyS-ZAEDLEI,1070
+conservation_enforcer-0.1.0.dist-info/METADATA,sha256=FdPcau46uCPHFSslqiKQf7OJh-uujkdnYMa8Ay1XmuU,6906
+conservation_enforcer-0.1.0.dist-info/WHEEL,sha256=K260EYznzXsJYBQGqmI8VTxEdiZYNvDZwW9cBh9-_MA,91
+conservation_enforcer-0.1.0.dist-info/top_level.txt,sha256=z0IaZgkBReeXdyGpzCuvho3Li6KopmQAJKILcs4LtLk,22
+conservation_enforcer-0.1.0.dist-info/RECORD,,

conservation_enforcer-0.1.0.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (83.0.0)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

conservation_enforcer-0.1.0.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 SuperInstance
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

conservation_enforcer-0.1.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+conservation_enforcer