# flake.nix
{
  inputs.gen-derive.url = "github:sini/gen-derive";
  inputs.gen-algebra.url = "github:sini/gen-algebra";
  outputs = { gen-derive, gen-algebra, nixpkgs, ... }:
    let derive = gen-derive.lib;
    in { /* ... */ };
}

# Or without flakes:
let derive = import ./gen-derive { inherit lib; gen-algebra = import ./gen-algebra {}; };
in { /* ... */ }

let
  derive = import ./gen-derive { inherit lib; gen-algebra = import ./gen-algebra {}; };

  # Define action vocabulary -- gen-derive classifies but doesn't interpret
  fx = derive.mkActions {
    structural = [ "spawn" "enrich" ];
    resolution = [ "edge" ];
  };

  rules = [
    # Function signature IS the condition (canTake pattern)
    (derive.fromFunction ({ host, ... }: [
      (fx.enrich { key = "isNixos"; value = true; })
      (fx.spawn { kind = "user"; })
    ]))

    # This rule fires only after enrichment adds "isNixos" to context
    (derive.mkRule {
      condition = { host = false; isNixos = false; };
      produce = _id: _ctx: [ (fx.edge { target = "logging"; }) ];
      identity = "nixos-edges";
    })
  ];

  result = derive.fixpoint {
    inherit rules;
    context = { host = { name = "igloo"; }; };
    match = derive.fromFunctionMatch;
    classify = fx.classify;
    phases = {
      structural = derive.entryAnywhere {};
      resolution = derive.entryAfter [ "structural" ] {};
    };
    extract = actions:
      lib.foldl' (acc: a:
        if a.__action == "enrich" then acc // { ${a.key} = a.value; } else acc
      ) {} (actions.structural or []);
    combine = ctx: ext: ctx // ext;
    eq = a: b: builtins.attrNames a == builtins.attrNames b;
  };
in {
  result.iterations   # 2 (enrichment converges on second pass)
  result.actions       # { structural = [ enrich, spawn ]; resolution = [ edge ]; }
}

dispatch {
  rules;              # [ rule ]
  id;                 # current position
  context;            # caller-defined context
  match;              # condition -> id -> ctx -> bool
  classify;           # action -> phase name
  phases;             # DAG of phase entries
  exclusive ? false;  # only highest-priority group fires
  fired ? {};         # pre-seeded fired identity set
  extract ? (_: {});       # { phase = [action]; } -> ctx delta (per-phase threading; default no-op)
  combine ? (ctx: _: ctx); # ctx -> delta -> ctx (default identity = no threading)
}
-> { actions; orderedPhases; context; fired; }

fixpoint {
  rules; context; match; classify; phases;
  extract;            # actions -> attrset (feedback from actions)
  combine;            # old ctx -> extracted -> new ctx
  eq;                 # old ctx -> new ctx -> bool (stability check)
  id ? null;
  exclusive ? false;
  maxIter ? 100;
}
-> { actions; orderedPhases; context; iterations; fired; }

mkRule {
  condition;            # opaque -- interpreted by match function
  produce;              # id -> ctx -> [ action ]
  nac ? null;           # negative application condition
  identity ? null;      # string for dedup, or null (anonymous)
  priority ? 0;         # higher fires first
  overrides ? [];       # identities of rules this one replaces
  phase ? null;         # phase name for stratified dispatch, or null (single-phase)
}
-> rule

fromFunction : fn -> rule

# { host, ... } is the condition -- required arg "host" must be in context
derive.fromFunction ({ host, ... }: [ (fx.spawn { kind = "user"; }) ])

# mkIntensional wrapping adds dedup identity
derive.fromFunction (mkIntensional "host-init" {} ({ host, ... }: [ ... ]))

fromFunctionMatch : condition -> id -> ctx -> bool

mkActions { phaseName = [ "tag" ... ]; ... }
-> { tag = args: { __action = "tag"; } // args; ...; classify = action -> phaseName; }

# Narrow a rule's condition
derive.restrict extraCondition rule

# One rule replaces another (sugar over overrides field)
derive.override original replacement

# Sequential: A's actions feed as context to B
derive.chain { extract; } ruleA ruleB

derive.entryAnywhere {}                    # no ordering constraints
derive.entryAfter [ "structural" ] {}      # fires after named phases
derive.entryBefore [ "collection" ] {}     # fires before named phases
derive.entryBetween [ "c" ] [ "a" ] {}     # between two sets
derive.topoSort phases                     # -> { result = [ { name; data; } ... ]; }

# Bridge gen-select selectors as gen-derive conditions
match = derive.adapters.select.mkMatch genSelect;

# CSS-like specificity counting for conflict resolution
derive.adapters.select.selectorSpecificity selector  # -> int