moveset 0.1.0__py3-none-any.whl

moveset/__init__.py

@@ -0,0 +1,5 @@
+"""Immutable linear pipelines over explicitly selected capability catalogs."""
+
+from .core import BoundPipeline, DefinitionError, Input, Pipeline, PipelineError, Ref, Result, Step, StepError
+
+__all__ = ["BoundPipeline", "DefinitionError", "Input", "Pipeline", "PipelineError", "Ref", "Result", "Step", "StepError"]

moveset/_validation.py

@@ -0,0 +1,121 @@
+"""Fallback JSON validation when hidden_moves does not export validate_json_value."""
+from __future__ import annotations
+import math
+from collections.abc import Mapping
+from typing import Any
+from hidden_moves.adapters.errors import CapabilityExposureError
+
+_KEYWORDS = frozenset({
+	"$schema", "title", "description", "default", "examples", "type", "enum",
+	"anyOf", "properties", "required", "additionalProperties", "items",
+})
+_TYPES = frozenset({"null", "boolean", "integer", "number", "string", "array", "object"})
+
+class ValueValidationError(ValueError):
+	"""A finite JSON value does not match the declared subset."""
+
+def check_schema(schema: Mapping[str, Any]) -> None:
+	if not isinstance(schema, Mapping):
+		raise CapabilityExposureError("Schema nodes must be objects.")
+	unknown = set(schema) - _KEYWORDS
+	if unknown:
+		raise CapabilityExposureError(f"Unsupported schema keywords: {", ".join(sorted(unknown))}.")
+	if "type" in schema:
+		types = schema["type"]
+		if isinstance(types, str):
+			types = (types,)
+		if not isinstance(types, (list, tuple)) or not types or any(
+			not isinstance(item, str) or item not in _TYPES for item in types
+		):
+			raise CapabilityExposureError("Schema type must be a supported JSON type or nonempty type list.")
+	if "enum" in schema and (not isinstance(schema["enum"], (list, tuple)) or not schema["enum"]):
+		raise CapabilityExposureError("Schema enum must be a nonempty array.")
+	if "anyOf" in schema:
+		branches = schema["anyOf"]
+		if not isinstance(branches, (list, tuple)) or not branches:
+			raise CapabilityExposureError("Schema anyOf must be a nonempty array.")
+		for branch in branches:
+			check_schema(branch)
+	properties = schema.get("properties", {})
+	if not isinstance(properties, Mapping):
+		raise CapabilityExposureError("Schema properties must be an object.")
+	for child in properties.values():
+		check_schema(child)
+	if "required" in schema:
+		required = schema["required"]
+		if not isinstance(required, (list, tuple)) or any(not isinstance(item, str) for item in required):
+			raise CapabilityExposureError("Schema required must be an array of property names.")
+		if len(required) != len(set(required)):
+			raise CapabilityExposureError("Schema required names must be unique.")
+	additional = schema.get("additionalProperties", True)
+	if not isinstance(additional, bool):
+		check_schema(additional)
+	if additional is False and any(name not in properties for name in schema.get("required", ())):
+		raise CapabilityExposureError("A closed schema requires a property it does not declare.")
+	if "items" in schema:
+		check_schema(schema["items"])
+
+def _matches(value: Any, kind: str) -> bool:
+	if kind == "null":
+		return value is None
+	if kind == "boolean":
+		return isinstance(value, bool)
+	if kind == "integer":
+		return type(value) is int or (type(value) is float and math.isfinite(value) and value.is_integer())
+	if kind == "number":
+		return type(value) is int or (type(value) is float and math.isfinite(value))
+	return isinstance(value, {"string": str, "array": list, "object": dict}[kind])
+
+def _equal(first: Any, second: Any) -> bool:
+	if isinstance(first, bool) != isinstance(second, bool):
+		return False
+	if isinstance(first, Mapping) and isinstance(second, Mapping):
+		return first.keys() == second.keys() and all(_equal(first[key], second[key]) for key in first)
+	if isinstance(first, (tuple, list)) and isinstance(second, (tuple, list)):
+		return len(first) == len(second) and all(_equal(a, b) for a, b in zip(first, second))
+	return first == second
+
+def validate_value(schema: Mapping[str, Any], value: Any, path: str = "$arguments") -> None:
+	if "type" in schema:
+		types = schema["type"]
+		types = (types,) if isinstance(types, str) else types
+		if not any(_matches(value, kind) for kind in types):
+			raise ValueValidationError(f"{path}: expected {" or ".join(types)}.")
+	if "enum" in schema and not any(_equal(value, item) for item in schema["enum"]):
+		raise ValueValidationError(f"{path}: value is outside the declared enum.")
+	if "anyOf" in schema:
+		for branch in schema["anyOf"]:
+			try:
+				validate_value(branch, value, path)
+				break
+			except ValueValidationError:
+				pass
+		else:
+			raise ValueValidationError(f"{path}: value does not match any declared type.")
+	if isinstance(value, dict):
+		properties = schema.get("properties", {})
+		for name in schema.get("required", ()):
+			if name not in value:
+				raise ValueValidationError(f"{path}.{name}: required argument is missing.")
+		additional = schema.get("additionalProperties", True)
+		for name, item in value.items():
+			if name in properties:
+				validate_value(properties[name], item, f"{path}.{name}")
+			elif additional is False:
+				raise ValueValidationError(f"{path}.{name}: unexpected argument.")
+			elif isinstance(additional, Mapping):
+				validate_value(additional, item, f"{path}.{name}")
+	if isinstance(value, list) and "items" in schema:
+		for index, item in enumerate(value):
+			validate_value(schema["items"], item, f"{path}[{index}]")
+
+def fallback_validate_json_value(schema: Mapping[str, Any], value: Any, path: str = "$value") -> Any:
+	from hidden_moves import MoveSchemaError
+	from hidden_moves.core.schema import json_value
+	check_schema(schema)
+	try:
+		copied = json_value(value)
+	except (MoveSchemaError, RecursionError) as error:
+		raise ValueValidationError(f"{path}: {error}") from error
+	validate_value(schema, copied, path)
+	return copied

moveset/core.py

@@ -0,0 +1,380 @@
+"""Explicit data mappings; capability and lifecycle behavior belongs to their owners."""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+import hashlib
+import inspect
+import json
+import math
+import re
+from typing import Any
+
+from hidden_moves.adapters import CapabilityCatalog
+try:
+    from hidden_moves.adapters import validate_json_value
+except ImportError:
+    from ._validation import fallback_validate_json_value as validate_json_value
+
+MAX_BYTES = 1_048_576
+MAX_DEPTH = 32
+MAX_STEPS = 256
+
+
+class PipelineError(ValueError):
+    """A definition or value cannot be used by this pipeline."""
+
+
+class DefinitionError(PipelineError):
+    """A passive definition is invalid."""
+
+
+class StepError(PipelineError):
+    """A selected operation or one of its mappings failed."""
+
+    def __init__(self, step: Step, message: str):
+        self.step_id = step.id
+        self.capability = step.capability
+        super().__init__(f"step {step.id!r} ({step.capability}): {message}")
+
+
+def identifier(value: str) -> str:
+    if type(value) is not str or not re.fullmatch(r"[A-Za-z0-9][A-Za-z0-9_.-]{0,127}", value):
+        raise DefinitionError("Identifiers require 1–128 ASCII letters, digits, dots, underscores or hyphens")
+    return value
+
+
+def canonical(value: Any) -> bytes:
+    try:
+        data = json.dumps(value, ensure_ascii=False, allow_nan=False, sort_keys=True,
+                          separators=(",", ":")).encode("utf-8")
+    except (TypeError, ValueError, UnicodeError, RecursionError) as error:
+        raise PipelineError("Expected finite UTF-8 JSON") from error
+    if len(data) > MAX_BYTES:
+        raise PipelineError(f"JSON exceeds {MAX_BYTES} bytes")
+    return data
+
+
+@dataclass(frozen=True)
+class Input:
+    name: str
+    path: tuple[str | int, ...] = ()
+
+    def __post_init__(self):
+        identifier(self.name)
+        _path(self.path)
+
+    def __getitem__(self, part: str | int) -> Input:
+        return Input(self.name, (*self.path, part))
+
+
+@dataclass(frozen=True)
+class Ref:
+    step: str
+    path: tuple[str | int, ...] = ()
+
+    def __post_init__(self):
+        identifier(self.step)
+        _path(self.path)
+
+    def __getitem__(self, part: str | int) -> Ref:
+        return Ref(self.step, (*self.path, part))
+
+
+def _path(path):
+    if type(path) is not tuple or len(path) > MAX_DEPTH or any(
+        type(part) not in (str, int) or (type(part) is int and part < 0) for part in path
+    ):
+        raise DefinitionError("Paths must be bounded tuples of string keys or nonnegative indexes")
+    canonical(list(path))
+
+
+@dataclass(frozen=True)
+class _Object:
+    items: tuple
+
+
+@dataclass(frozen=True)
+class _Array:
+    items: tuple
+
+
+def freeze(value, depth=0, *, expressions=True):
+    if depth > MAX_DEPTH:
+        raise DefinitionError(f"Values exceed depth {MAX_DEPTH}")
+    if expressions and isinstance(value, (Input, Ref)):
+        return value
+    if type(value) is dict:
+        if any(type(key) is not str for key in value):
+            raise DefinitionError("Object keys must be strings")
+        return _Object(tuple((key, freeze(item, depth + 1, expressions=expressions)) for key, item in value.items()))
+    if type(value) is list:
+        return _Array(tuple(freeze(item, depth + 1, expressions=expressions) for item in value))
+    if value is None or type(value) in (str, bool, int) or (type(value) is float and math.isfinite(value)):
+        canonical(value)
+        return value
+    raise DefinitionError("Values must be finite JSON or explicit Input/Ref expressions")
+
+
+def thaw(value):
+    if isinstance(value, _Object):
+        return {key: thaw(item) for key, item in value.items}
+    if isinstance(value, _Array):
+        return [thaw(item) for item in value.items]
+    return value
+
+
+def copy_json(value):
+    copied = thaw(freeze(value, expressions=False))
+    canonical(copied)
+    return copied
+
+
+def expression(value):
+    if isinstance(value, Input):
+        return {"input": {"name": value.name, "path": list(value.path)}}
+    if isinstance(value, Ref):
+        return {"ref": {"step": value.step, "path": list(value.path)}}
+    if isinstance(value, _Object):
+        return {"object": {key: expression(item) for key, item in value.items}}
+    if isinstance(value, _Array):
+        return {"array": [expression(item) for item in value.items]}
+    return {"value": value}
+
+
+def references(value):
+    if isinstance(value, (Ref, Input)):
+        yield value
+    elif isinstance(value, (_Object, _Array)):
+        for item in (item for _, item in value.items) if isinstance(value, _Object) else value.items:
+            yield from references(item)
+
+
+def resolve(value, inputs, results):
+    if isinstance(value, (Input, Ref)):
+        selected = inputs if isinstance(value, Input) else results
+        key = value.name if isinstance(value, Input) else value.step
+        try:
+            selected = selected[key]
+            for part in value.path:
+                if (type(part) is str and type(selected) is dict) or (type(part) is int and type(selected) is list):
+                    selected = selected[part]
+                else:
+                    raise KeyError(part)
+        except (KeyError, IndexError) as error:
+            raise PipelineError(f"Cannot resolve {expression(value)}") from error
+        return copy_json(selected)
+    if isinstance(value, _Object):
+        return {key: resolve(item, inputs, results) for key, item in value.items}
+    if isinstance(value, _Array):
+        return [resolve(item, inputs, results) for item in value.items]
+    return value
+
+
+@dataclass(frozen=True, init=False)
+class Step:
+    id: str
+    capability: str
+    _arguments: _Object
+
+    def __init__(self, id: str, capability: str, arguments: dict):
+        identifier(id)
+        if type(capability) is not str or not capability or len(capability) > 512:
+            raise DefinitionError("A step requires a bounded capability name")
+        if type(arguments) is not dict:
+            raise DefinitionError("Step arguments must be an object")
+        object.__setattr__(self, "id", id)
+        object.__setattr__(self, "capability", capability)
+        object.__setattr__(self, "_arguments", freeze(arguments))
+        canonical(expression(self._arguments))
+
+    @property
+    def arguments(self):
+        return thaw(self._arguments)
+
+
+@dataclass(frozen=True, init=False)
+class Pipeline:
+    name: str
+    version: str
+    steps: tuple[Step, ...]
+    _outputs: _Object
+
+    def __init__(self, name: str, *, version: str, steps: tuple[Step, ...], outputs: dict):
+        identifier(name)
+        identifier(version)
+        if type(steps) is not tuple or not 1 <= len(steps) <= MAX_STEPS or any(type(step) is not Step for step in steps):
+            raise DefinitionError(f"A pipeline requires a tuple of 1–{MAX_STEPS} Steps")
+        previous = set()
+        for step in steps:
+            if step.id in previous:
+                raise DefinitionError(f"Duplicate step {step.id!r}")
+            for ref in references(step._arguments):
+                if isinstance(ref, Ref) and ref.step not in previous:
+                    raise DefinitionError(f"step {step.id!r}: reference must name an earlier step: {ref.step!r}")
+            previous.add(step.id)
+        if type(outputs) is not dict:
+            raise DefinitionError("Outputs must be an explicit object")
+        frozen = freeze(outputs)
+        if any(isinstance(ref, Ref) and ref.step not in previous for ref in references(frozen)):
+            raise DefinitionError("Output reference names an unknown step")
+        for key, value in (("name", name), ("version", version), ("steps", steps), ("_outputs", frozen)):
+            object.__setattr__(self, key, value)
+        canonical(self.manifest)
+
+    @property
+    def outputs(self):
+        return thaw(self._outputs)
+
+    @property
+    def manifest(self):
+        return {"schema": 1, "name": self.name, "version": self.version,
+                "steps": [{"id": step.id, "capability": step.capability,
+                           "arguments": expression(step._arguments)} for step in self.steps],
+                "outputs": expression(self._outputs)}
+
+    def bind(self, catalog: CapabilityCatalog, *, catalog_version: str) -> BoundPipeline:
+        return BoundPipeline(self, catalog, catalog_version)
+
+
+def _partial(schema, value, inputs=None):
+    """Validate known portions; unknown producer values are checked at invocation."""
+    if isinstance(value, Ref):
+        return
+    if isinstance(value, Input):
+        if inputs is not None:
+            validate_json_value(schema, resolve(value, inputs, {}))
+        return
+    if "anyOf" in schema:
+        for branch in schema["anyOf"]:
+            try:
+                _partial(branch, value, inputs)
+                break
+            except (ValueError, TypeError):
+                pass
+        else:
+            raise DefinitionError("Mapping does not match any declared type")
+    if isinstance(value, _Object):
+        values = dict(value.items)
+        if "type" in schema:
+            validate_json_value({"type": schema["type"]}, {})
+        if any(name not in values for name in schema.get("required", ())):
+            raise DefinitionError("A required argument is missing")
+        properties = schema.get("properties", {})
+        additional = schema.get("additionalProperties", True)
+        for key, item in value.items:
+            if key not in properties and additional is False:
+                raise DefinitionError(f"Unexpected argument {key!r}")
+            _partial(properties.get(key, additional if isinstance(additional, dict) else {}), item, inputs)
+    elif isinstance(value, _Array):
+        if "type" in schema:
+            validate_json_value({"type": schema["type"]}, [])
+        for item in value.items:
+            _partial(schema.get("items", {}), item, inputs)
+    else:
+        validate_json_value(schema, value)
+    if not tuple(references(value)):
+        validate_json_value(schema, thaw(value))
+
+
+@dataclass(frozen=True)
+class Result:
+    """A run's caller-owned JSON snapshots."""
+
+    results: dict
+    outputs: dict
+
+
+@dataclass(frozen=True, init=False)
+class BoundPipeline:
+    definition: Pipeline
+    catalog: CapabilityCatalog
+    catalog_version: str
+
+    def __init__(self, definition, catalog, catalog_version):
+        if not isinstance(catalog, CapabilityCatalog):
+            raise DefinitionError("Bind an explicitly selected CapabilityCatalog")
+        identifier(catalog_version)
+        for step in definition.steps:
+            try:
+                schema = _schema_json(catalog.describe(step.capability).input_schema)
+                _partial(schema, step._arguments)
+            except Exception as error:
+                raise StepError(step, str(error)) from error
+        object.__setattr__(self, "definition", definition)
+        object.__setattr__(self, "catalog", catalog)
+        object.__setattr__(self, "catalog_version", catalog_version)
+        canonical(self.manifest)
+
+    @property
+    def manifest(self):
+        names = sorted({step.capability for step in self.definition.steps})
+        return {"definition": self.definition.manifest, "catalog_version": self.catalog_version,
+                "capabilities": [{"name": name, "input": _schema_json(self.catalog.describe(name).input_schema),
+                                  "output": _schema_json(self.catalog.describe(name).output_schema),
+                                  "async": self.catalog.describe(name).is_async} for name in names]}
+
+    @property
+    def fingerprint(self):
+        return hashlib.sha256(canonical(self.manifest)).hexdigest()
+
+    def prepare(self, inputs: dict):
+        if type(inputs) is not dict:
+            raise PipelineError("Run inputs must be a JSON object")
+        inputs = copy_json(inputs)
+        for step in self.definition.steps:
+            try:
+                _partial(_schema_json(self.catalog.describe(step.capability).input_schema), step._arguments, inputs)
+            except Exception as error:
+                raise StepError(step, str(error)) from error
+        for ref in references(self.definition._outputs):
+            if isinstance(ref, Input):
+                resolve(ref, inputs, {})
+        return inputs
+
+    def finish(self, inputs, results):
+        return Result(copy_json(results), resolve(self.definition._outputs, inputs, results))
+
+    def _invoke(self, step, inputs, results):
+        return self.catalog.invoke(step.capability, resolve(step._arguments, inputs, results))
+
+    def run(self, inputs: dict) -> Result:
+        inputs = self.prepare(inputs)
+        if any(self.catalog.describe(step.capability).is_async for step in self.definition.steps):
+            raise DefinitionError("Pipeline contains async capabilities; use arun()")
+        results = {}
+        for step in self.definition.steps:
+            try:
+                result = self._invoke(step, inputs, results)
+                if inspect.isawaitable(result):
+                    if inspect.iscoroutine(result):
+                        result.close()
+                    raise DefinitionError("Capability returned an awaitable; use arun()")
+                results[step.id] = copy_json(self.catalog.serialize_result(step.capability, result))
+            except Exception as error:
+                raise StepError(step, str(error)) from error
+        return self.finish(inputs, results)
+
+    async def arun(self, inputs: dict) -> Result:
+        inputs = self.prepare(inputs)
+        results = {}
+        for step in self.definition.steps:
+            try:
+                result = self._invoke(step, inputs, results)
+                if inspect.isawaitable(result):
+                    result = await result
+                results[step.id] = copy_json(self.catalog.serialize_result(step.capability, result))
+            except Exception as error:
+                raise StepError(step, str(error)) from error
+        return self.finish(inputs, results)
+
+
+def _schema_json(schema):
+    """Catalog metadata uses frozen mappings/tuples; normalize without changing values."""
+    from collections.abc import Mapping
+
+    if isinstance(schema, Mapping):
+        return {key: _schema_json(item) for key, item in schema.items()}
+    if isinstance(schema, (list, tuple)):
+        return [_schema_json(item) for item in schema]
+    return schema

moveset/sequence.py

@@ -0,0 +1,70 @@
+"""Optional compilation into func_seq's public Script and lifecycle contract."""
+
+import sys
+
+if sys.version_info < (3, 14):
+    raise ImportError("The moveset sequence adapter requires Python 3.14 or newer")
+
+import hashlib
+import inspect
+
+from func_seq import Ref as SequenceRef, Script
+
+from .core import BoundPipeline, DefinitionError, Input, Ref, StepError, _Array, _Object, canonical, copy_json, resolve
+
+
+def _mapping(value, inputs):
+    if isinstance(value, Input):
+        return resolve(value, inputs, {})
+    if isinstance(value, Ref):
+        return SequenceRef(value.step, value.path)
+    if isinstance(value, _Object):
+        return {key: _mapping(item, inputs) for key, item in value.items}
+    if isinstance(value, _Array):
+        return [_mapping(item, inputs) for item in value.items]
+    return value
+
+
+def _wrapper(bound, step, asynchronous):
+    def invoke(arguments):
+        try:
+            result = bound.catalog.invoke(step.capability, arguments)
+            if inspect.isawaitable(result):
+                if inspect.iscoroutine(result):
+                    result.close()
+                raise DefinitionError("Capability returned an awaitable; compile with asynchronous=True")
+            return copy_json(bound.catalog.serialize_result(step.capability, result))
+        except Exception as error:
+            raise StepError(step, str(error)) from error
+
+    async def ainvoke(arguments):
+        try:
+            result = bound.catalog.invoke(step.capability, arguments)
+            if inspect.isawaitable(result):
+                result = await result
+            return copy_json(bound.catalog.serialize_result(step.capability, result))
+        except Exception as error:
+            raise StepError(step, str(error)) from error
+
+    return ainvoke if asynchronous else invoke
+
+
+def compile_script(bound: BoundPipeline, inputs: dict, *, asynchronous: bool = False) -> Script:
+    """Compile validated mappings; return func_seq's executor without wrapping state.
+
+    Use asynchronous=True with Script.arun for mixed/awaitable capabilities. The
+    execution mode is part of compatibility identity. Control, pace, observers,
+    checkpoint, retry and restart are passed directly to Script.run/arun.
+    """
+    if type(asynchronous) is not bool:
+        raise DefinitionError("asynchronous must be a boolean")
+    inputs = bound.prepare(inputs)
+    if not asynchronous and any(bound.catalog.describe(step.capability).is_async for step in bound.definition.steps):
+        raise DefinitionError("Async capabilities require asynchronous=True and Script.arun")
+    version = hashlib.sha256(canonical({"pipeline": bound.fingerprint, "inputs": inputs,
+                                       "asynchronous": asynchronous})).hexdigest()
+    script = Script(bound.definition.name, version=version)
+    for step in bound.definition.steps:
+        script.add_function(_wrapper(bound, step, asynchronous),
+                            _mapping(step._arguments, inputs), step_id=step.id)
+    return script

moveset-0.1.0.dist-info/METADATA

@@ -0,0 +1,65 @@
+Metadata-Version: 2.4
+Name: moveset
+Version: 0.1.0
+Summary: Explicit linear composition of selected Python capabilities.
+Author: ellainng
+License-Expression: MIT
+License-File: LICENSE
+Requires-Dist: hidden-moves>=0.1.0
+Requires-Dist: func-seq>=0.1.0 ; python_full_version >= '3.14' and extra == 'sequence'
+Requires-Python: >=3.11
+Project-URL: Source, https://github.com/wispsy/moveset
+Project-URL: Issues, https://github.com/wispsy/moveset/issues
+Project-URL: Project, https://github.com/orgs/wispsy/projects/23
+Provides-Extra: sequence
+Description-Content-Type: text/markdown
+
+# Moveset
+
+Explicit linear composition of selected Python capabilities. Python 3.11+.
+
+```python
+from hidden_moves import Moves
+from hidden_moves.adapters import CapabilityCatalog
+from moveset import Input, Pipeline, Ref, Step
+
+def normalize(text: str) -> str:
+    return " ".join(text.lower().split())
+
+moves = Moves()
+moves.learn(normalize)
+selected = CapabilityCatalog(moves, ["normalize"])
+definition = Pipeline("example", version="1", steps=(
+    Step("clean", "normalize", {"text": Input("text")}),
+), outputs={"text": Ref("clean")})
+bound = definition.bind(selected, catalog_version="text-v1")
+assert bound.run({"text": " Hello WORLD "}).outputs == {"text": "hello world"}
+```
+
+Definitions snapshot nested arguments and outputs. `Input("payload")["key"][0]`
+selects run data; `Ref("clean")` selects an earlier result. Mappings are explicit:
+scalar results are never automatically wrapped in objects. Binding validates
+selected capability names and known argument shapes. Run preflight validates all
+known inputs before effects; dynamic result paths and values are checked before
+the dependent call. Hidden Moves owns its documented schema subset and callable
+binding. No provider is activated by creating or executing a pipeline.
+
+`arun(inputs)` awaits mixed sync/async steps in order. `run` rejects declared async
+steps before executing anything. Cancellation propagates; ordinary runs start
+fresh. Results are caller-owned finite JSON snapshots, bounded to 1 MiB with depth
+32; definitions have at most 256 steps. StepError identifies the step/capability
+and retains the original cause. There is no retry, persistence or concurrency in
+the core.
+
+The bound fingerprint includes mappings, schemas, async flags and catalog version.
+Change `catalog_version` when callable behavior, resources, defaults or configuration
+change; this is not source authentication. The optional lifecycle adapter belongs
+in the `sequence` profile and delegates durable execution to func_seq.
+
+This source development profile pins Hidden Moves to an immutable revision. It is
+independently built and versioned; release requirements and publication are tracked
+separately in the [Wispsy Composition Project](https://github.com/orgs/wispsy/projects/23).
+
+Build with `uv build --out-dir dist`; `python scripts/qualify.py dist` installs the
+wheel and source archive outside the checkout and runs the contract tests. CI
+qualifies Python 3.11 on Linux/Windows and Python 3.14 on Linux/macOS/Windows.

moveset-0.1.0.dist-info/RECORD

@@ -0,0 +1,9 @@
+moveset/__init__.py,sha256=AH6aFF9jWipBHXtSOcp3JHLF8oKbPDVdhx930vaJ7Ew,315
+moveset/_validation.py,sha256=3r22tH89xnQ0vDvRGjFdnkXM7sQDzW9_MEU9vT137Wo,5411
+moveset/core.py,sha256=5MPFH6r4NDQN0iCx6Gt0XAKKrtnt292zHkcxSrPoMHY,14358
+moveset/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+moveset/sequence.py,sha256=w4qbFJUcHM777HUeii_nn6VOBGhqHVTivtw_e9Vs--Y,3026
+moveset-0.1.0.dist-info/licenses/LICENSE,sha256=MJiaArfnOql8NJRA2TI9JIYDOoiis3Rh8xQruzBRXoU,1066
+moveset-0.1.0.dist-info/WHEEL,sha256=MWx7psoF7KNST9G72pGtiBYuaXRXQXBk9pw5R6FzYko,80
+moveset-0.1.0.dist-info/METADATA,sha256=QfzzOicr_Gl7ya2hht2orVkDU7u-Xjs1J8WPpJ02PEw,3057
+moveset-0.1.0.dist-info/RECORD,,

moveset-0.1.0.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: uv 0.13.7
+Root-Is-Purelib: true
+Tag: py3-none-any

moveset-0.1.0.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Ella Inng
+
+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.