@voxgig/sdkgen-langpack 0.0.1

package/.sdk/tm/dart/lib/feature/secrets/plugin/order.dart

@@ -0,0 +1,172 @@
+// VENDORED: @voxgig/plugin sdk-20260908-1556-0 (dart/lib/order.dart)
+// Source: https://github.com/voxgig/plugin @ 48392f5e2b6d1434ee9b1a4a9a11f4480aaeb46a  [tag: sdk-20260908-1556-0]
+// License: MIT (c) voxgig - see repository LICENSE. Do not edit: resync from upstream.
+/// Ordering (section 7) - one rule, one place.
+///
+/// sdkgen grew two special cases in `makeOptions` (`test`, then `station`)
+/// and the third was not far off. This sort is the whole replacement, and
+/// the tiers are in this order for a reason:
+///
+///   1 constraints   before/after edges, by ref or by name
+///   2 bands         integer, lower first, default 0
+///   3 declaration   ties break by `pos`
+///
+/// CONSTRAINTS BEAT BANDS precisely so the correct tool wins when both are
+/// present. A band expresses a genuine cross-cutting layer; a constraint
+/// expresses a relationship between two specific things; and a band chosen
+/// by trial and error to fix an ordering bug is a bug wearing a number.
+library;
+
+import 'types.dart' as t;
+import 'ref.dart' as r;
+
+/// One node of the sort. An internal shape, never a corpus value.
+class OrderNode {
+  final String ref;
+  final int pos;
+  final dynamic order;
+  OrderNode(this.ref, this.pos, this.order);
+}
+
+int orderBand(OrderNode b) => t.asInt(t.get(b.order ?? {}, 'band')) ?? 0;
+
+/// Was a constraint stated? An absent value and an EMPTY LIST are both
+/// no-constraint - and an empty list is TRUTHY in most languages, which is
+/// exactly how this class of bug survives a reading.
+bool orderDeclared(dynamic spec) {
+  if (spec == null) return false;
+  if (spec is List) return spec.any((one) => one != '');
+  return spec != '';
+}
+
+/// One spelling or a LIST of them. A list fans out to the UNION of what each
+/// names, so after: ['a','b'] means after BOTH, and the same instance named
+/// twice - once by name, once by ref - is one edge.
+///
+/// Matching is by REF, or by NAME across all of that definition's instances
+/// (section 7) - which is the whole reason the two spellings exist.
+List<String> orderTargets(dynamic spec, List<OrderNode> nodes) {
+  final specs = spec is List ? spec : [spec];
+  final hit = <String>[];
+  for (final one in specs) {
+    for (final b in nodes) {
+      if (hit.contains(b.ref)) continue;
+      if (b.ref == one || r.refName(b.ref) == one) hit.add(b.ref);
+    }
+  }
+  return hit;
+}
+
+List<String> resolveOrder(List<OrderNode> bindings, [dynamic pin]) {
+  final nodes = bindings;
+  final byref = {for (final b in nodes) b.ref: b};
+
+  // Constraints are edges. A constraint naming an ABSENT binding is
+  // satisfied VACUOUSLY (section 7) - a plugin ordered `after: 'test'` must
+  // load in a host with no test plugin. That is sdkgen's __after__
+  // behaviour, kept.
+  final edges = {for (final b in nodes) b.ref: <String>[]};
+
+  for (final b in nodes) {
+    final block = b.order ?? {};
+    if (orderDeclared(t.get(block, 'after'))) {
+      for (final target in orderTargets(t.get(block, 'after'), nodes)) {
+        edges[target]!.add(b.ref);
+      }
+    }
+    if (orderDeclared(t.get(block, 'before'))) {
+      edges[b.ref]!.addAll(orderTargets(t.get(block, 'before'), nodes));
+    }
+  }
+
+  final indeg = {for (final b in nodes) b.ref: 0};
+  for (final tos in edges.values) {
+    for (final to in tos) {
+      indeg[to] = indeg[to]! + 1;
+    }
+  }
+
+  // Stable topological sort. Among ready nodes, band first (lower runs
+  // first), then `pos` - the position the DOCUMENT visibly states, not the
+  // order instances happened to load and not the incarnation `seq`.
+  final out = <String>[];
+  var ready = nodes.where((b) => indeg[b.ref] == 0).toList();
+
+  while (ready.isNotEmpty) {
+    ready = t.stableSortBy(ready, (b) => [orderBand(b), b.pos]);
+    final next = ready.removeAt(0);
+    out.add(next.ref);
+    for (final to in edges[next.ref]!) {
+      indeg[to] = indeg[to]! - 1;
+      if (indeg[to] == 0) ready.add(byref[to]!);
+    }
+  }
+
+  if (out.length != nodes.length) {
+    final stuck =
+        nodes.where((b) => !out.contains(b.ref)).map((b) => b.ref).toList();
+    t.fail('plugin_order_cycle',
+        'before/after constraints cycle: ${stuck.join(' -> ')}',
+        {'cycle': stuck});
+  }
+
+  return applyPin(out, edges, pin);
+}
+
+/// A PIN IS NOT A CONSTRAINT (section 7).
+///
+/// Constraints and bands are negotiable by definition - they are what
+/// plugins and documents say they want, and the sort's job is to satisfy
+/// them all. A pin is the host stating a structural invariant of its own
+/// architecture, which is a different kind of claim and must not lose a tie
+/// to a document.
+///
+/// So a pin PLACES the binding at the named end, and an ordering that would
+/// move it away is `plugin_order_pinned` - rejected, not honoured into a
+/// broken wrap.
+List<String> applyPin(
+    List<String> order, Map<String, List<String>> edges, dynamic pin) {
+  if (pin == null) return order;
+  final out = List<String>.from(order);
+
+  // SORTED, not insertion order. A pin map is data - it can arrive from a
+  // host's own construction options in any order, and two names pinned to
+  // the same end are order-sensitive (`{b:'first', a:'first'}` and
+  // `{a:'first', b:'first'}` give different results). A dart map iterates
+  // in insertion order and a Go map has no order at all, so leaving it
+  // unstated made the same declaration mean different things in different
+  // ports.
+  for (final name in t.sortedKeys(pin)) {
+    final want = t.get(pin, name);
+    final idx = out.indexWhere((ref) => r.refName(ref) == name);
+    if (idx < 0) continue;
+
+    // `first`/`outermost` is index 0; `last`/`innermost` is the end.
+    // Section 6.2 makes the first chain binding outermost, which is why the
+    // vocabulary is positional and why the two spellings pair this way.
+    final wantFirst = want == 'first' || want == 'outermost';
+    final ref = out.removeAt(idx);
+    if (wantFirst) {
+      out.insert(0, ref);
+    } else {
+      out.add(ref);
+    }
+  }
+
+  // Now check that the placement did not break a constraint. This is the
+  // half that makes a pin a rejection rather than an override: the host
+  // wins on position, but it does not get to silently discard a
+  // relationship a plugin declared.
+  final at = {for (var i = 0; i < out.length; i++) out[i]: i};
+  for (final from in edges.keys) {
+    for (final to in edges[from]!) {
+      if (at[from]! <= at[to]!) continue;
+      t.fail(
+          'plugin_order_pinned',
+          'a pin would move a binding an ordering constrains: '
+              '$from must precede $to',
+          {'before': from, 'after': to});
+    }
+  }
+  return out;
+}

package/.sdk/tm/dart/lib/feature/secrets/plugin/plugin.dart

@@ -0,0 +1,23 @@
+// VENDORED: @voxgig/plugin sdk-20260908-1556-0 (dart/lib/plugin.dart)
+// Source: https://github.com/voxgig/plugin @ 48392f5e2b6d1434ee9b1a4a9a11f4480aaeb46a  [tag: sdk-20260908-1556-0]
+// License: MIT (c) voxgig - see repository LICENSE. Do not edit: resync from upstream.
+/// The canonical surface `make parity` checks (AGENTS.md section 4). Small
+/// on purpose (section 19): everything else is methods on the host and
+/// instance types, because a library that grows a second public entry point
+/// per feature is a library twenty ports pay for twice.
+library;
+
+export 'types.dart';
+export 'ref.dart';
+export 'version.dart';
+export 'capability.dart';
+export 'resolve.dart';
+export 'export.dart';
+export 'order.dart';
+export 'point.dart';
+export 'config.dart';
+export 'env.dart';
+export 'graph.dart';
+export 'depend.dart';
+export 'catalog.dart';
+export 'host.dart';

package/.sdk/tm/dart/lib/feature/secrets/plugin/point.dart

@@ -0,0 +1,117 @@
+// VENDORED: @voxgig/plugin sdk-20260908-1556-0 (dart/lib/point.dart)
+// Source: https://github.com/voxgig/plugin @ 48392f5e2b6d1434ee9b1a4a9a11f4480aaeb46a  [tag: sdk-20260908-1556-0]
+// License: MIT (c) voxgig - see repository LICENSE. Do not edit: resync from upstream.
+/// Extension points (section 6). Three kinds, chosen because they are what
+/// the two existing systems actually needed, and no more.
+///
+/// A PLUGIN NEVER MUTATES THE HOST. That inversion is what makes
+/// deactivation possible: sdkgen's `utility.fetcher = wrapped` is not
+/// undoable, but "this instance holds slot 3 of the request chain" is
+/// undoable in O(1). OSGi named it the whiteboard pattern in 2004, in a
+/// paper called *Listeners Considered Harmful*, and for exactly this reason.
+library;
+
+import 'types.dart' as t;
+
+/// EVERY BINDING IS ARITY TWO, `(next, arg)`, hook and chain alike. `next`
+/// is null for a hook. One signature means this file does not have to know
+/// which kind of point it is holding - and the kind is the HOST's property,
+/// not the binding's.
+typedef BindingFn = dynamic Function(dynamic next, dynamic arg);
+
+/// A live binding. An internal shape, never a corpus value.
+class Binding {
+  final String ref;
+  final String point;
+  final BindingFn fn;
+  int band;
+  Binding(this.ref, this.point, this.fn, this.band);
+  Binding withBand(int b) => Binding(ref, point, fn, b);
+}
+
+/// Section 6.1: "fan-out" is not one answer but four. In a language with
+/// asynchrony, "call every binding" hides a decision - start them all and
+/// wait, await each in turn, or do not wait - and a design that leaves it
+/// unsaid gets four different answers from four ports, in the concurrency
+/// behaviour of production code no corpus entry happens to cover.
+///
+/// DART IS A PORT WHERE THAT IS LOUD: `Future.wait` is right there, and
+/// making `emit` return one would turn every hook point into a scheduling
+/// decision and every ordering assertion into a race. The host stays
+/// synchronous (section 5.2) and the modes stay data.
+const modes = ['emit', 'parallel', 'serial', 'bail'];
+
+/// Fan-out. Return values are ignored except in `bail`.
+dynamic pointEmit(List<Binding> bindings, String mode, dynamic arg) {
+  if (mode == 'bail') {
+    // Stops at the first binding that RETURNS A VALUE - the "handled, stop"
+    // case. A `null` RETURN DECLINES (section 6.1): dart has one way to say
+    // nothing, and the model's rule is written to that rather than to
+    // JavaScript's null/undefined pair. `!= null`, NOT truthiness - `false`
+    // is a value.
+    for (final b in bindings) {
+      final v = b.fn(null, arg);
+      if (v != null) return v;
+    }
+    return null;
+  }
+
+  final errors = <String>[];
+  for (final b in bindings) {
+    try {
+      b.fn(null, arg);
+    } catch (e) {
+      // `emit` raises synchronously; the collecting modes gather.
+      if (mode == 'emit') rethrow;
+      errors.add(t.messageOf(e));
+    }
+  }
+  return mode == 'emit' ? null : errors;
+}
+
+/// Composition: b1(b2(b3(base))), FIRST BINDING OUTERMOST (section 6.2).
+///
+/// Recomputed by the host whenever the live set changes, and cached between
+/// changes. Plugins receive `next` as an argument; they never see or store
+/// the previous value of anything. A plugin that stashes `next` and calls
+/// it after deactivation is a bug the host cannot prevent, and this says so
+/// rather than pretending otherwise.
+dynamic Function(dynamic) compose(
+    List<Binding> bindings, dynamic Function(dynamic) base) {
+  var next = base;
+  for (var i = bindings.length - 1; i >= 0; i--) {
+    // `fn` and `inner` are declared INSIDE the loop, so each layer closes
+    // over its own pair. Dart captures the variable rather than the value,
+    // and hoisting either would leave every layer calling the last one.
+    final fn = bindings[i].fn;
+    final inner = next;
+    next = (arg) => fn(inner, arg);
+  }
+  return next;
+}
+
+/// The winner and the losers on a provider point.
+class Picked {
+  final Binding? winner;
+  final List<String> shadowed;
+  Picked(this.winner, this.shadowed);
+}
+
+/// At most one live implementation (section 6.3). The winner is the highest
+/// band, ties broken by ref sort, and THE LOSERS ARE VISIBLE rather than
+/// silently ignored.
+Picked pointProvider(List<Binding> bindings, dynamic spec) {
+  if (bindings.isEmpty) return Picked(null, []);
+
+  if (t.truthy(t.get(spec, 'exclusive')) && bindings.length > 1) {
+    final refs = bindings.map((b) => b.ref).toList()..sort();
+    t.fail(
+        'plugin_point_exclusive',
+        'point is exclusive and has ${bindings.length} bindings: '
+            '${refs.join(', ')}',
+        {'refs': refs});
+  }
+
+  final ranked = t.stableSortBy(bindings, (b) => [-b.band, b.ref]);
+  return Picked(ranked[0], ranked.sublist(1).map((b) => b.ref).toList());
+}

package/.sdk/tm/dart/lib/feature/secrets/plugin/ref.dart

@@ -0,0 +1,105 @@
+// VENDORED: @voxgig/plugin sdk-20260908-1556-0 (dart/lib/ref.dart)
+// Source: https://github.com/voxgig/plugin @ 48392f5e2b6d1434ee9b1a4a9a11f4480aaeb46a  [tag: sdk-20260908-1556-0]
+// License: MIT (c) voxgig - see repository LICENSE. Do not edit: resync from upstream.
+/// Identity: name+tag, written `name$tag` (section 4).
+///
+/// The four pure functions, and the whole of what `ref` pins. They are the
+/// first thing a new port implements and the first corpus section it
+/// passes.
+library;
+
+import 'types.dart' as t;
+
+/// Section 4: `^[a-zA-Z@][a-zA-Z0-9.~_\-/]*$`, max 1024.
+///
+/// `hasMatch` on an anchored pattern, and the anchors are `^` and `$`
+/// WITHOUT `multiLine` - dart's `$` matches only at the end of input when
+/// multiLine is off, so `'abc\n'` is rejected. Turning multiLine on here
+/// would admit a ref grammar with a newline in it, which is the trap ruby
+/// and java each document from the other side.
+final _nameRe = RegExp(r'^[a-zA-Z@][a-zA-Z0-9.~_\-/]*$');
+
+/// Section 4: `^[a-zA-Z0-9.~_-]+$`, max 1024, or empty.
+///
+/// The asymmetry with a name is deliberate: a tag MAY start with a digit
+/// because auto-tagging assigns integer tags (`stripe$1`), and a tag admits
+/// neither `@` nor `/` because a name is a package specifier and a tag is
+/// not.
+final _tagRe = RegExp(r'^[a-zA-Z0-9.~_-]+$');
+
+const refMax = 1024;
+
+bool checkName(dynamic name) =>
+    name is String && name.isNotEmpty && name.length <= refMax &&
+    _nameRe.hasMatch(name);
+
+bool checkTag(dynamic tag) {
+  if (tag is! String) return false;
+  // The empty tag is an ordinary tag (section 4 rule 2). The
+  // single-instance case writes no tag and never learns tags exist.
+  if (tag.isEmpty) return true;
+  return tag.length <= refMax && _tagRe.hasMatch(tag);
+}
+
+/// `name$tag` -> the pair. Canonicalizing: `stripe$` and `stripe` both give
+/// tag ''.
+Map<String, dynamic> parseRef(dynamic str) {
+  if (str is! String) t.fail('plugin_bad_name', 'ref must be a string');
+  // Split on the FIRST `$`. Nothing in the grammar decides this - `$` is in
+  // neither character class - so the corpus is the arbiter (section 4 rule
+  // 5), and it picks the split that blames the part actually at fault:
+  // `a$b$c` is a good name with a bad tag, not the reverse.
+  final cut = str.indexOf(r'$');
+  final name = cut < 0 ? str : str.substring(0, cut);
+  final tag = cut < 0 ? '' : str.substring(cut + 1);
+
+  if (!checkName(name)) {
+    t.fail('plugin_bad_name', 'invalid plugin name: $name', {'name': name});
+  }
+  if (!checkTag(tag)) {
+    t.fail('plugin_bad_tag', 'invalid plugin tag: $tag',
+        {'name': name, 'tag': tag});
+  }
+  return {'name': name, 'tag': tag};
+}
+
+/// The pair -> `name$tag`. An empty tag NEVER writes the separator, which
+/// is the half of canonicalization `formatRef` owns: parse tolerates
+/// `stripe$`, format never produces it, so a round trip is idempotent.
+String formatRef(dynamic name, [dynamic tag]) {
+  final t2 = tag ?? '';
+  if (!checkName(name)) {
+    t.fail('plugin_bad_name', 'invalid plugin name: $name', {'name': name});
+  }
+  if (!checkTag(t2)) {
+    t.fail('plugin_bad_tag', 'invalid plugin tag: $t2',
+        {'name': name, 'tag': t2});
+  }
+  return (t2 as String).isEmpty ? name as String : '$name\$$t2';
+}
+
+/// The canonical spelling of a ref. Section 4 rule 5: ports must
+/// canonicalize before comparison.
+String canonRef(dynamic str) {
+  final r = parseRef(str);
+  return formatRef(r['name'], r['tag']);
+}
+
+/// `canonRef` for the internal callers that want the input back unchanged
+/// when it is not well formed. NEVER use it where a bad ref must be
+/// reported - the corpus pins plugin_bad_name at every public entry.
+String canon(dynamic str) {
+  try {
+    return canonRef(str);
+  } on t.PluginError {
+    return str as String;
+  }
+}
+
+String refName(dynamic str) {
+  try {
+    return parseRef(str)['name'] as String;
+  } on t.PluginError {
+    return str as String;
+  }
+}

package/.sdk/tm/dart/lib/feature/secrets/plugin/resolve.dart

@@ -0,0 +1,58 @@
+// VENDORED: @voxgig/plugin sdk-20260908-1556-0 (dart/lib/resolve.dart)
+// Source: https://github.com/voxgig/plugin @ 48392f5e2b6d1434ee9b1a4a9a11f4480aaeb46a  [tag: sdk-20260908-1556-0]
+// License: MIT (c) voxgig - see repository LICENSE. Do not edit: resync from upstream.
+/// Dynamic resolution (section 10.2) - name to candidate module ids.
+///
+/// PURE. It returns the ids a host WOULD try, in order; it does not load
+/// anything. That separation is what lets the corpus pin resolution in
+/// every language including those with no dynamic loading at all, and it is
+/// why section 15.4 puts real module loading in per-port integration tests
+/// rather than here.
+library;
+
+import 'types.dart' as t;
+
+const defaultSources = [
+  {
+    'kind': 'module',
+    'prefix': ['@voxgig/plugin-', 'voxgig-plugin-', 'plugin-', ''],
+  }
+];
+
+List<String> resolveCandidates(String name, [dynamic sources]) {
+  // A SCOPED NAME RESOLVES VERBATIM ONLY (section 10.2). `@acme/thing` is
+  // already a package id; prefixing it produces
+  // `@voxgig/plugin-@acme/thing`, which is not a thing that can exist.
+  if (name.startsWith('@')) return [name];
+
+  final list = (sources == null || (sources as List).isEmpty)
+      ? defaultSources
+      : sources;
+  final out = <String>[];
+
+  for (final src in list) {
+    switch (t.get(src, 'kind')) {
+      case 'module':
+        var prefixes = t.get(src, 'prefix') as List?;
+        if (prefixes == null || prefixes.isEmpty) prefixes = [''];
+        for (final p in prefixes) {
+          final id = '$p$name';
+          if (!out.contains(id)) out.add(id);
+        }
+        break;
+      case 'path':
+        final dir = (t.get(src, 'dir') as String).replaceAll(RegExp(r'/+$'), '');
+        final id = '$dir/$name';
+        if (!out.contains(id)) out.add(id);
+        break;
+    }
+  }
+  return out;
+}
+
+/// A MODULE PATH IS NOT A NAME (section 10.2). The ref grammar starts a
+/// name with a letter or `@`, so `./local/thing` is not a ref and never
+/// reaches candidate generation - seneca allows a path where a plugin name
+/// goes, and this design deliberately does not, because a ref is an ADDRESS
+/// WITHIN A HOST and a path is a LOCATION ON A DISK.
+List<dynamic> resolveFrom(dynamic from) => [from];

package/.sdk/tm/dart/lib/feature/secrets/plugin/types.dart

@@ -0,0 +1,201 @@
+// VENDORED: @voxgig/plugin sdk-20260908-1556-0 (dart/lib/types.dart)
+// Source: https://github.com/voxgig/plugin @ 48392f5e2b6d1434ee9b1a4a9a11f4480aaeb46a  [tag: sdk-20260908-1556-0]
+// License: MIT (c) voxgig - see repository LICENSE. Do not edit: resync from upstream.
+/// The value model, the error type, and the JSON writer.
+///
+/// DART DRAWS ALMOST EVERY DISTINCTION THE MODEL NEEDS. `Map` is not
+/// `List`, a map holds `null` as a value, `containsKey` separates an
+/// authored null from an absent key, and `true == 1` is false. What it
+/// does NOT give is a stable sort or an ordered map iteration that means
+/// anything - see `stableSortBy` and `sortedKeys` below, both of which are
+/// load-bearing rather than tidiness.
+library;
+
+/// Section 5.1's seven statuses, and no more.
+const statuses = [
+  'declared', 'loaded', 'pending', 'live', 'failed', 'loading', 'closing'
+];
+
+/// Section 12's detail keys, in the order a message renders them. FIXED,
+/// not the map's: a message is a searchable log line, and a line whose
+/// fields move between runs is not.
+const detailOrder = [
+  'ref', 'point', 'name', 'key', 'spec', 'refs', 'kind', 'directive',
+  'cycle', 'holders', 'cause'
+];
+
+/// The value at a key, or null. Absence and null read the same here.
+dynamic get(dynamic m, String k) => m is Map ? m[k] : null;
+
+/// PRESENCE, which is what distinguishes an authored null from absence.
+bool has(dynamic m, String k) => m is Map && m.containsKey(k);
+
+/// The keys of a map, SORTED - every walk of a map goes through here.
+///
+/// A dart `Map` literal is a `LinkedHashMap`, so iteration is INSERTION
+/// order. That is deterministic within one run and meaningless across two:
+/// a document parsed from different byte order, or a registry rebuilt in a
+/// different sequence, iterates differently. Every walk sorts.
+List<String> sortedKeys(dynamic m) {
+  if (m is! Map) return [];
+  final out = m.keys.map((k) => k as String).toList();
+  out.sort();
+  return out;
+}
+
+/// JSON truthiness: null and false, and nothing else, are false. Dart has
+/// no truthiness of its own - `if (0)` does not compile - so this is where
+/// the model's rule is written down.
+bool truthy(dynamic v) => !(v == null || v == false);
+
+/// An INTEGER, and only when the value is one. Section 7's band is an
+/// integer the document wrote as one; `true` and `'2'` are not bands, and
+/// dart's `is int` excludes both.
+int? asInt(dynamic v) {
+  if (v is int) return v;
+  if (v is double && v == v.floorToDouble()) return v.toInt();
+  return null;
+}
+
+/// A STABLE sort by a comparable key.
+///
+/// DART'S `List.sort` IS NOT STABLE, and it is not stable in practice
+/// rather than merely in the documentation: sorting two hundred elements
+/// by a two-valued key visibly reorders equal ones. Section 7's
+/// comparators fall through to a `pos` or ref tie-break that javascript's
+/// stable sort resolves BY POSITION, so without this a teardown order
+/// changes between two runs of the same process.
+List<T> stableSortBy<T>(List<T> list, List<Object> Function(T) keyOf) {
+  final decorated = <List<Object>>[];
+  for (var i = 0; i < list.length; i++) {
+    decorated.add([keyOf(list[i]), i]);
+  }
+  decorated.sort((a, b) {
+    final c = compareKeys(a[0] as List<Object>, b[0] as List<Object>);
+    return c != 0 ? c : (a[1] as int).compareTo(b[1] as int);
+  });
+  return decorated.map((d) => list[d[1] as int]).toList();
+}
+
+/// Compare two sort keys element by element. A key is a list of numbers,
+/// strings and nested lists, which is what lets `rankKey` express "absent
+/// version sorts last" as a leading flag rather than as a comparator.
+int compareKeys(List<Object> a, List<Object> b) {
+  for (var i = 0; i < a.length && i < b.length; i++) {
+    final x = a[i], y = b[i];
+    final c = (x is List && y is List)
+        ? compareKeys(x.cast<Object>(), y.cast<Object>())
+        : (x as Comparable).compareTo(y);
+    if (c != 0) return c;
+  }
+  return a.length.compareTo(b.length);
+}
+
+/// JSON equality: same type, then same value.
+///
+/// `true == 1` is false in dart, so the bool guard the other dynamic ports
+/// need is not required here. `1 == 1.0` IS true, as it is in ruby and
+/// javascript, and no corpus entry turns on the difference.
+bool same(dynamic a, dynamic b) {
+  if (a is Map && b is Map) {
+    if (a.length != b.length) return false;
+    for (final k in a.keys) {
+      if (!b.containsKey(k) || !same(a[k], b[k])) return false;
+    }
+    return true;
+  }
+  if (a is List || b is List) {
+    if (a is! List || b is! List || a.length != b.length) return false;
+    for (var i = 0; i < a.length; i++) {
+      if (!same(a[i], b[i])) return false;
+    }
+    return true;
+  }
+  if (a is Map || b is Map) return false;
+  return a == b;
+}
+
+/// COMPACT JSON. A whole double renders without its fraction, so `1.0` and
+/// `1` spell the same - the corpus writes both and a message quoting one
+/// must not depend on which. Written here rather than taken from
+/// `dart:convert` because `jsonEncode` walks a map in insertion order and
+/// throws on a value it does not know, and this needs sorted keys and
+/// `"(opaque)"`.
+String encode(dynamic v) {
+  if (v == null) return 'null';
+  if (v is bool) return v ? 'true' : 'false';
+  if (v is int) return '$v';
+  if (v is double) return v == v.floorToDouble() ? '${v.toInt()}' : '$v';
+  if (v is String) return encodeString(v);
+  if (v is List) return '[${v.map(encode).join(',')}]';
+  if (v is Map) {
+    return '{${sortedKeys(v).map((k) => '${encodeString(k)}:${encode(v[k])}').join(',')}}';
+  }
+  return '"(opaque)"';
+}
+
+String encodeString(String s) {
+  final b = StringBuffer('"');
+  for (final c in s.codeUnits) {
+    switch (c) {
+      case 0x22: b.write('\\"'); break;
+      case 0x5c: b.write('\\\\'); break;
+      case 0x0a: b.write('\\n'); break;
+      case 0x0d: b.write('\\r'); break;
+      case 0x09: b.write('\\t'); break;
+      default:
+        if (c < 0x20) {
+          b.write('\\u${c.toRadixString(16).padLeft(4, '0')}');
+        } else {
+          b.writeCharCode(c);
+        }
+    }
+  }
+  b.write('"');
+  return b.toString();
+}
+
+/// Every error carries a section 12 code. Ports compare by CODE and never
+/// by message: wording is a port's own business, and pinning the words
+/// would make every translation a corpus change. The FORMAT, however, is
+/// pinned - a parseable message is what makes a log searchable across
+/// twenty languages.
+class PluginError implements Exception {
+  final String code;
+  final String text;
+  final Map<String, dynamic> details;
+  final String message;
+
+  PluginError(this.code, this.text, this.details)
+      : message = formatError(code, text, details);
+
+  @override
+  String toString() => message;
+}
+
+/// `plugin/<code>: <text> [<key>=<value> ...]`
+///
+/// Values render as COMPACT JSON, so a value containing a space or a
+/// bracket cannot break the parse, and a list renders as a JSON array. The
+/// bracket is absent entirely when no field applies.
+String formatError(String code, String text, Map<String, dynamic> details) {
+  final parts = detailOrder
+      .where((k) => details.containsKey(k))
+      .map((k) => '$k=${encode(details[k])}')
+      .toList();
+  final tail = parts.isEmpty ? '' : ' [${parts.join(' ')}]';
+  return 'plugin/$code: $text$tail';
+}
+
+/// Throw a section 12 error. One spelling, so every raise site reads the
+/// same.
+Never fail(String code, String text, [Map<String, dynamic>? details]) {
+  throw PluginError(code, text, details ?? {});
+}
+
+/// The section 12 code of an error, or '' for one this library did not
+/// throw. The corpus compares by code, so the driver needs one place that
+/// knows how to read it.
+String codeOf(Object e) => e is PluginError ? e.code : '';
+
+String messageOf(Object e) => e is PluginError ? e.message : '$e';