@voxgig/sdkgen 4.8.2 → 4.9.0

package/project/.sdk/tm/py/pkg/feature/secrets/voxgig_plugin/config.py

@@ -0,0 +1,333 @@
+# VENDORED: @voxgig/plugin 0.1.6 (python/voxgig_plugin/config.py)
+# Source: https://github.com/voxgig/plugin @ b48ae643eb0eb56c5ebe3198da98cecdf6a7f7fc  [tag: sdk-20260907-0029-0]
+# License: MIT (c) voxgig - see repository LICENSE. Do not edit: resync from upstream.
+"""The declarative document (section 9): normalization, and the ten-level
+precedence ladder.
+
+TWO FUNCTIONS, AND THE SPLIT BETWEEN THEM IS FORCED.
+
+`normalize_config` normalizes STRUCTURE and ENTRY KEYS. It does not merge
+options, and cannot: section 9.4 makes merge behaviour a property of the
+definition's option SHAPE, which normalization has never seen. A
+normalizer that flattened the option layers would make `$MERGE: append`
+unimplementable at load time, because the layers it must concatenate would
+already be collapsed.
+
+`resolve_options` applies the ladder, and it is the only place that knows
+the shape.
+"""
+
+from .types import fail
+from .ref import canon_ref, parse_ref
+
+
+# ---------------------------------------------------------------------
+# normalize_config
+# ---------------------------------------------------------------------
+
+def normalize_config(spec):
+    doc = (spec or {}).get('doc') or {}
+    keys = (spec or {}).get('keys') or {}
+    ikey = keys.get('instance') or 'instance'
+    dkey = keys.get('default') or 'default'
+    reserved = (spec or {}).get('reserved') or []
+    profile = (spec or {}).get('profile')
+
+    # The rename is applied at TWO PLACES AND NO OTHERS: the document
+    # root, and every profile.<name> overlay root (section 9.1). A rename
+    # applied only at the root would leave `profile.prod.sdk` untranslated
+    # and silently drop every environment override the host depends on.
+    # Recursing further would be worse: option data is the definition's.
+    baseinst = doc.get(ikey)
+    basedef = doc.get(dkey) or {}
+
+    overlay = None
+    if profile and isinstance(doc.get('profile'), dict):
+        overlay = doc['profile'].get(profile)
+    overinst = overlay.get(ikey) if isinstance(overlay, dict) else None
+    overdef = (overlay.get(dkey) if isinstance(overlay, dict) else None) or {}
+
+    # Entry layers, base then overlay, each as {ref -> entry} plus the
+    # order the form implies.
+    base = entries(baseinst)
+    over = entries(overinst)
+
+    for group in (base['map'], over['map'], basedef, overdef):
+        for ref in group:
+            checkreserved(ref, reserved)
+
+    # A PARTIAL ARRAY IS NOT A FILTER (section 9.1). sdkgen learned this
+    # the hard way: deriving order from a partial array silently dropped
+    # config-activated features. Refs in the base but absent from the
+    # overlay still load, in sorted position AFTER the listed ones. A
+    # profile may also INTRODUCE a ref the base never declared.
+    order = []
+    for ref in over['order']:
+        if ref not in order:
+            order.append(ref)
+    # The remainder keeps the BASE's own order - array position for the
+    # array form, sorted refs for the map form. Re-sorting here would
+    # discard an array document's positional order entirely, which is the
+    # one thing the array form exists to express.
+    for ref in base['order']:
+        if ref not in order:
+            order.append(ref)
+
+    instance = {}
+    for i, ref in enumerate(order):
+        b = base['map'].get(ref)
+        o = over['map'].get(ref)
+
+        # MERGE THE ENTRIES AS AUTHORED, THEN APPLY DEFAULTS TO THE RESULT
+        # (section 9.3). A safety rule, not a tidiness one: if the overlay
+        # had its defaults filled in before merging it would carry a
+        # synthesized active:true and overwrite a base's false - silently
+        # re-enabling a deliberately disabled integration in production.
+        active = pick(o, 'active', pick(b, 'active', True))
+        start = pick(o, 'start', pick(b, 'start', 'eager'))
+        block = pick(o, 'order', pick(b, 'order', None))
+
+        # Option layers, levels 3-6, IN LADDER ORDER. Never merged here.
+        layers = []
+        name = parse_ref(ref)['name']
+        for src in (basedef.get(name), b, overdef.get(name), o):
+            if isinstance(src, dict) and 'options' in src:
+                layers.append(src['options'])
+
+        entry = {'pos': i, 'active': active, 'start': start,
+                 'optionlayers': layers}
+        if None is not block:
+            entry['order'] = block
+        instance[ref] = entry
+
+    # `default` DECLARES NOTHING (section 9.3). It is a base for every
+    # instance of that definition; it does not create one, and an entry
+    # for a name with no instances is inert rather than an error - which
+    # is what makes a shared library of defaults shippable.
+    defout = {}
+    for name in basedef:
+        defout[name] = basedef[name]
+    for name in overdef:
+        defout[name] = overdef[name]
+
+    return {'instance': instance, 'order': order, 'default': defout}
+
+
+def entries(src):
+    """Both document forms reduce to {ref -> entry} plus the order the
+    form implies: array POSITION for the array form, sorted refs for the
+    map form."""
+    out = {'map': {}, 'order': []}
+    if None is src:
+        return out
+
+    if isinstance(src, list):
+        for item in src:
+            ref = canon_ref(item.get('ref'))
+            out['map'][ref] = item
+            out['order'].append(ref)
+        return out
+
+    # Map-form refs arrive as KEYS, through a different path than an array
+    # element's `ref` field - and must canonicalize the same way.
+    for key in src:
+        out['map'][canon_ref(key)] = src[key]
+    # Byte-wise, NOT locale-aware and NOT case-folded. All-lowercase refs
+    # sort identically under all three, so only mixed input discriminates:
+    # '@' is 0x40, uppercase 0x41-0x5A, lowercase 0x61-0x7A. Python's
+    # `sorted` on str is code-point order, which is exactly that.
+    out['order'] = sorted(out['map'])
+    return out
+
+
+def checkreserved(ref, reserved):
+    """Section 9.1: reservation is all-or-nothing per NAME, so the tagged
+    forms go too. A configuration surface that can disable the thing
+    reading it is not a surface, it is a trap."""
+    if 0 == len(reserved):
+        return
+    if parse_ref(ref)['name'] in reserved:
+        fail('plugin_ref_reserved', 'ref is reserved by the host: ' + ref,
+             {'ref': ref})
+
+
+def pick(src, key, default):
+    """PRESENCE decides, not truthiness and not None. A JSON `null` is a
+    present value in JavaScript (`undefined !== null`), so it must be one
+    here."""
+    if isinstance(src, dict) and key in src:
+        return src[key]
+    return default
+
+
+# ---------------------------------------------------------------------
+# resolve_options - section 9.3's ten levels, and 9.4's merge directives
+# ---------------------------------------------------------------------
+
+def resolve_options(spec):
+    shape = spec.get('shape') or {}
+    check_shape(shape)
+
+    ref = canon_ref(spec['ref'])
+    name = parse_ref(ref)['name']
+    doc = spec.get('doc') or {}
+    profile = spec.get('profile')
+
+    overlay = None
+    if profile and isinstance(doc.get('profile'), dict):
+        overlay = doc['profile'].get(profile)
+    overlay = overlay if isinstance(overlay, dict) else {}
+
+    # ONE ordered merge, lowest to highest. Levels 3-6 are not two
+    # namespaces collapsed separately and composed afterwards: that
+    # inverts the rule that PROFILE SPECIFICITY OUTRANKS DEFINITION
+    # SPECIFICITY, so a prod per-definition default would lose to a base
+    # instance value.
+    layers = [
+        defaultsof(shape),                          # 1
+        spec.get('hostdefaults'),                   # 2
+        optsof(doc.get('default'), name),           # 3
+        optsof(doc.get('instance'), ref),           # 4
+        optsof(overlay.get('default'), name),       # 5
+        optsof(overlay.get('instance'), ref),       # 6
+        spec.get('env'),                            # 7
+        spec.get('hostoptions'),                    # 8
+        spec.get('loadoptions'),                    # 9
+        spec.get('patch'),                          # 10
+    ]
+
+    out = {}
+    for layer in layers:
+        if None is layer:
+            continue
+        out = mergeone(out, layer, shape)
+    return out
+
+
+def defaultsof(shape):
+    """The shape's non-directive values are the level-1 defaults."""
+    out = {}
+    for key in shape:
+        value = shape[key]
+        if isinstance(value, dict) and '$MERGE' in value:
+            continue
+        out[key] = value
+    return out
+
+
+def optsof(src, key):
+    if None is src:
+        return None
+    # The array form is equivalent to the map form (section 9.1).
+    if isinstance(src, list):
+        for item in src:
+            if canon_ref(item.get('ref')) == key:
+                return item.get('options')
+        return None
+    for name in src:
+        if canon_ref(name) == key:
+            entry = src[name]
+            return entry.get('options') if isinstance(entry, dict) else None
+    return None
+
+
+def mergeone(base, over, shape):
+    """Merge ONE layer onto the accumulator, honouring the shape's
+    directives. The directive holds at EVERY precedence level, not only
+    between document levels - section 9.4 makes it a property of the
+    shape, which does not know which layer a value arrived from."""
+    if None is over:
+        return base
+    if not ismap(base) or not ismap(over):
+        return clone(over)
+
+    out = dict(base)
+
+    for key in over:
+        directive = None
+        if isinstance(shape, dict) and isinstance(shape.get(key), dict):
+            directive = shape[key].get('$MERGE')
+        b = out.get(key)
+        o = over[key]
+
+        if 'replace' == directive:
+            out[key] = clone(o)
+        elif 'append' == directive:
+            bl = b if isinstance(b, list) else []
+            ol = o if isinstance(o, list) else [o]
+            out[key] = bl + ol
+        elif isinstance(directive, dict) and 'deep' in directive:
+            out[key] = deepto(b, o, directive['deep'])
+        else:
+            # Library default: deep for maps, REPLACE for lists.
+            # struct.merge is element-wise by index, which for option maps
+            # is nearly always wrong - ["a"] over ["x","y","z"] yielding
+            # ["a","y","z"] is the defect station hit on
+            # secrets.providers.
+            out[key] = mergeone(b, o, None) if ismap(b) and ismap(o) else clone(o)
+    return out
+
+
+def deepto(base, over, n):
+    """Merge N levels below this key, replace below that."""
+    if 0 >= n:
+        return clone(over)
+    if not ismap(base) or not ismap(over):
+        return clone(over)
+    out = dict(base)
+    for key in over:
+        out[key] = deepto(out.get(key), over[key], n - 1)
+    return out
+
+
+# Section 9.4: N is an integer of at least 1, and everything else is an
+# error.
+#
+# `{"deep": 0}` is rejected DESPITE having an obvious reading, because
+# "replace at this key" already has a spelling and two spellings for one
+# behaviour is the defect class this repo exists to avoid. Without the
+# stated domain each port picks its own reading - reject, replace,
+# unlimited merge, or clamp to 1 - and the same document resolves
+# differently per language.
+MERGE_WORDS = ['replace', 'append']
+
+
+def check_shape(shape):
+    if not ismap(shape):
+        return
+    for key in shape:
+        value = shape[key]
+        if not ismap(value) or '$MERGE' not in value:
+            continue
+        directive = value['$MERGE']
+
+        if isinstance(directive, str):
+            if directive not in MERGE_WORDS:
+                fail('plugin_shape_invalid',
+                     'invalid $MERGE directive at ' + key + ': ' + directive,
+                     {'key': key, 'directive': directive})
+            continue
+        if ismap(directive) and 'deep' in directive:
+            n = directive['deep']
+            # `isinstance(True, int)` is True in Python, so `{"deep":
+            # true}` would pass an int check and be read as depth 1.
+            if (not isinstance(n, int)) or isinstance(n, bool) or n < 1:
+                fail('plugin_shape_invalid',
+                     'invalid $MERGE deep at ' + key + ': ' + str(n),
+                     {'key': key, 'directive': directive})
+            continue
+        fail('plugin_shape_invalid',
+             'invalid $MERGE directive at ' + key + ': ' + str(directive),
+             {'key': key, 'directive': directive})
+
+
+def ismap(value):
+    return isinstance(value, dict)
+
+
+def clone(value):
+    if isinstance(value, list):
+        return [clone(v) for v in value]
+    if isinstance(value, dict):
+        return {k: clone(v) for k, v in value.items()}
+    return value

package/project/.sdk/tm/py/pkg/feature/secrets/voxgig_plugin/depend.py

@@ -0,0 +1,198 @@
+# VENDORED: @voxgig/plugin 0.1.6 (python/voxgig_plugin/depend.py)
+# Source: https://github.com/voxgig/plugin @ b48ae643eb0eb56c5ebe3198da98cecdf6a7f7fc  [tag: sdk-20260907-0029-0]
+# License: MIT (c) voxgig - see repository LICENSE. Do not edit: resync from upstream.
+"""Dependency cardinality, policy, and the restart graph (section 11.3).
+
+TWO AXES, BOTH DECLARED BY THE DEFINITION THAT HAS THE REQUIREMENT,
+because only it knows what it can cope with:
+
+               | static (default)          | dynamic
+  -------------|---------------------------|--------------------------
+  mandatory    | unmet -> pending;         | unmet -> pending;
+  (default)    | lost  -> pending,         | lost  -> STAYS LIVE,
+               |          recursively      |          notified
+  -------------|---------------------------|--------------------------
+  optional:true| never gates activation;   | never gates activation;
+               | a change deactivates and  | a change is a
+               | reactivates               | notification, nothing else
+
+`dynamic` means the plugin has said, IN WRITING, that it can survive its
+provider being swapped underneath it. It is not the default because most
+plugins cannot, and the cost of wrongly assuming they can is a live
+instance holding a dead reference.
+
+The rebinding-preference axis is deliberately omitted. OSGi has reluctant
+vs greedy and it is a knob every author must understand to read anyone
+else's component; we take always-reluctant. Three axes were more than the
+model can carry across twenty ports.
+"""
+
+from .types import fail
+from .ref import try_ref
+
+
+def normrequire(raw):
+    """A bare string is shorthand for `{name}`."""
+    if isinstance(raw, str):
+        return {'name': raw}
+    return dict(raw or {})
+
+
+def requirements(options):
+    """The requirements a definition declared, normalized.
+
+    BOTH AXES ARE READ AT TWO LEVELS, AND THE PER-REQUIREMENT ONE WINS.
+
+    The instance-level `policy` and `optional` list are how a DOCUMENT
+    states the axis without editing the definition, and they apply to
+    every requirement. The per-requirement form is the one section 11.1's
+    object syntax exists for, and it is strictly more expressive: an
+    instance that is `static` on its store and `dynamic` on its metrics
+    cannot be written at all at the instance level, and that is the
+    ordinary case rather than an exotic one.
+
+    `optional` unions rather than overriding - both spellings are
+    statements that this requirement need not gate activation, and there
+    is no reading under which one of them means "actually, mandatory".
+    """
+    options = options or {}
+    raw = options.get('requires') or []
+    marked = options.get('optional') or []
+    fallback = options.get('policy')
+
+    out = []
+    for item in raw:
+        req = normrequire(item)
+        if req.get('optional') or req.get('name') in marked:
+            req['optional'] = True
+        if None is req.get('policy') and None is not fallback:
+            req['policy'] = fallback
+        out.append(req)
+    return out
+
+
+def restartsonloss(req):
+    """Does losing this requirement's SELECTED provider restart the
+    consumer? The mandatory ones under `static`, and the `static` optional
+    ones - both make a capability change deactivate and reactivate.
+    `dynamic` never restarts: mandatory-dynamic stays live and is
+    notified, optional-dynamic is a notification and nothing else."""
+    return 'dynamic' != (req.get('policy') or 'static')
+
+
+def gatesactivation(req):
+    """Does an unmet requirement keep the consumer out of `live`?
+
+    Cardinality alone decides this, NOT policy. `dynamic` is a statement
+    about surviving a SWAP, not about starting without the thing at all -
+    a mandatory-dynamic consumer still waits in `pending` for its first
+    provider. Conflating the two would let a plugin that declared it can
+    cope with replacement activate with nothing to call.
+    """
+    return True is not req.get('optional')
+
+
+def restartcausing(req):
+    """Edges that can cause a restart, which is exactly the set a cycle
+    must be detected over (section 11.3).
+
+    Those are the mandatory requirements AND THE `static` OPTIONAL ONES,
+    because both make a capability change deactivate and reactivate the
+    consumer - and a cycle of restarts does not settle: A comes up, B
+    restarts, which changes B's capability, which restarts A,
+    indefinitely.
+
+    ONLY `dynamic` OPTIONAL EDGES ARE EXCLUDED, and they are the ones the
+    exclusion was for: two plugins that optionally and dynamically consume
+    each other's capabilities both activate happily, neither gates on the
+    other, and each is merely notified when the other appears. Nothing
+    restarts, so nothing oscillates.
+
+    An earlier draft of section 11.3 excluded EVERY optional edge and
+    thereby admitted the non-terminating case it was trying to permit.
+    """
+    return gatesactivation(req) or restartsonloss(req)
+
+
+def dependencycycle(nodes):
+    """A cycle through restart-causing requirements is
+    `plugin_dependency_cycle`, detected AT LOAD - before anything runs,
+    because the failure it describes is a non-terminating reconcile and
+    the only safe time to report that is before it starts.
+
+    The graph is over capabilities, not refs: an edge runs from a consumer
+    to EVERY node that provides what it needs, because any of them could
+    be the one selected and a cycle through any is a cycle. A node also
+    satisfies its own name as a ref (section 11.1), which is why the ref
+    is a provider of itself here.
+    """
+    # TWO INDEXES, NOT ONE MERGED MAP. Capability names and refs are
+    # matched differently - a capability by its exact name, a ref through
+    # the canonical spelling (section 4 rule 5) - and one map keyed by
+    # both can only do one of them. Keyed by both and looked up raw, as
+    # this was, a cycle spelled `a$`/`b$` found no providers and EVADED
+    # the load-time check that exists to catch a non-terminating
+    # reconcile.
+    bycap = {}
+    isref = {}
+    for node in nodes:
+        isref[node['ref']] = True
+        for cap in node['provides']:
+            bycap.setdefault(cap, []).append(node['ref'])
+
+    edges = {}
+    for node in nodes:
+        out = []
+        for req in node['requires']:
+            if not restartcausing(req):
+                continue
+            frm = list(bycap.get(req['name'], []))
+            # A node satisfies its own name AS A REF (section 11.1),
+            # canonically - exactly what `_providersof` does at runtime.
+            asref = try_ref(req['name'])
+            if asref is not None and isref.get(asref) and asref not in frm:
+                frm.append(asref)
+            for p in frm:
+                if p != node['ref'] and p not in out:
+                    out.append(p)
+        edges[node['ref']] = sorted(out)
+
+    # Iterative DFS with an explicit stack: twenty ports, and several of
+    # them have no recursion budget worth relying on.
+    WHITE, GREY, BLACK = 0, 1, 2
+    colour = {node['ref']: WHITE for node in nodes}
+
+    for start in sorted(edges):
+        if WHITE != colour[start]:
+            continue
+        path = [start]
+        stack = [[start, 0]]
+        colour[start] = GREY
+
+        while 0 < len(stack):
+            top = stack[-1]
+            if top[1] >= len(edges[top[0]]):
+                colour[top[0]] = BLACK
+                stack.pop()
+                path.pop()
+                continue
+            nxt = edges[top[0]][top[1]]
+            top[1] += 1
+            if GREY == colour[nxt]:
+                # Report the cycle itself, not the walk that found it.
+                return path[path.index(nxt):] + [nxt]
+            if BLACK == colour[nxt]:
+                continue
+            colour[nxt] = GREY
+            path.append(nxt)
+            stack.append([nxt, 0])
+    return None
+
+
+def checkcycle(nodes):
+    """Raise on a cycle, naming it. Separate from the detector so the
+    detector stays pure and corpus-testable."""
+    cycle = dependencycycle(nodes)
+    if None is not cycle:
+        fail('plugin_dependency_cycle',
+             'requirements cycle: ' + ' -> '.join(cycle), {'cycle': cycle})

package/project/.sdk/tm/py/pkg/feature/secrets/voxgig_plugin/env.py

@@ -0,0 +1,147 @@
+# VENDORED: @voxgig/plugin 0.1.6 (python/voxgig_plugin/env.py)
+# Source: https://github.com/voxgig/plugin @ b48ae643eb0eb56c5ebe3198da98cecdf6a7f7fc  [tag: sdk-20260907-0029-0]
+# License: MIT (c) voxgig - see repository LICENSE. Do not edit: resync from upstream.
+"""Environment overrides (section 9.5) - level 7 of the ladder.
+
+One prefix, so nothing drifts: `VOXGIG_PLUGIN_*`.
+
+  VOXGIG_PLUGIN_PROFILE            the profile name
+  VOXGIG_PLUGIN_<REF>_<PATH>       one option
+  VOXGIG_PLUGIN_ACTIVE/INACTIVE    comma-separated refs, INACTIVE wins
+
+THE ENCODING IS LOSSY, AND THIS SAYS SO RATHER THAN PRETENDING OTHERWISE.
+Ref and path are upper-snake with `$` -> `__` and `.` -> `_`. But `_` is
+legal in a name and in a tag, and the mapping folds case, so `retry$fast`
+and `retry__fast` both encode to `RETRY__FAST`, as do `Retry$fast` and
+`retry$Fast`.
+
+Rather than restrict a grammar the rest of the stack already uses, the
+host DETECTS THE COLLISION: it encodes every ref it holds, and a key two
+refs claim is `plugin_env_ambiguous`, naming both. The affected pair stays
+configurable by document and by API, just not by environment - which is
+the honest trade.
+
+Pure: a function over a string map and a ref set. The corpus tests it
+without touching a real environment.
+"""
+
+import json
+
+from .types import fail
+from .ref import canon_ref, parse_ref
+
+PREFIX = 'VOXGIG_PLUGIN_'
+
+
+def encode_ref(ref):
+    """`retry$fast` -> `RETRY__FAST`."""
+    return ref.replace('$', '__').replace('.', '_').upper()
+
+
+def apply_env(spec):
+    env = (spec or {}).get('env') or {}
+    refs = [canon_ref(r) for r in ((spec or {}).get('refs') or [])]
+    reserved = (spec or {}).get('reserved') or []
+    out = {'options': {}, 'active': [], 'inactive': []}
+
+    # Encode every ref the host holds, and refuse a key that two of them
+    # claim. Done up front so the collision is reported even when no
+    # environment variable exercises it - a latent ambiguity is still an
+    # ambiguity, and finding it at deploy time is the failure this exists
+    # to prevent.
+    byencoded = {}
+    for ref in refs:
+        byencoded.setdefault(encode_ref(ref), []).append(ref)
+    for encoded in sorted(byencoded):
+        if 1 < len(byencoded[encoded]):
+            pair = sorted(byencoded[encoded])
+            fail('plugin_env_ambiguous',
+                 'refs collide in the environment encoding as ' + encoded +
+                 ': ' + ', '.join(pair),
+                 {'encoded': encoded, 'refs': pair})
+
+    # Longest encoded ref first, so `retry$fast` wins over `retry` on
+    # `RETRY__FAST_MIN`. Shortest-first would read the tag as a path.
+    encoded = sorted(byencoded, key=lambda e: -len(e))
+
+    for key in sorted(env):
+        if not key.startswith(PREFIX):
+            continue
+        rest = key[len(PREFIX):]
+
+        if 'PROFILE' == rest:
+            out['profile'] = env[key]
+            continue
+
+        if 'ACTIVE' == rest or 'INACTIVE' == rest:
+            for raw in split(env[key]):
+                ref = canon_ref(raw)
+                # The reservation covers EVERY input layer (section 9.1).
+                # VOXGIG_PLUGIN_INACTIVE=station is easier to set than
+                # editing a config file, and INACTIVE has the final word -
+                # so guarding documents alone would leave the one lever
+                # this mechanism exists to deny wide open.
+                checkreserved(ref, reserved)
+                out['active' if 'ACTIVE' == rest else 'inactive'].append(ref)
+            continue
+
+        found = None
+        for enc in encoded:
+            if rest == enc or rest.startswith(enc + '_'):
+                found = enc
+                break
+        if None is found:
+            continue                     # not for any ref this host holds
+        ref = byencoded[found][0]
+        checkreserved(ref, reserved)
+
+        if rest == found:
+            continue                     # a ref with no path sets nothing
+        path = rest[len(found) + 1:].lower().split('_')
+
+        node = out['options'].get(ref)
+        if not isinstance(node, dict):
+            node = {}
+            out['options'][ref] = node
+        for step in path[:-1]:
+            child = node.get(step)
+            if not isinstance(child, dict):
+                child = {}
+                node[step] = child
+            node = child
+        node[path[-1]] = parsevalue(env[key])
+
+    return out
+
+
+def split(value):
+    return [s.strip() for s in str(value).split(',') if 0 < len(s.strip())]
+
+
+def checkreserved(ref, reserved):
+    if 0 == len(reserved):
+        return
+    if parse_ref(ref)['name'] in reserved:
+        fail('plugin_ref_reserved', 'ref is reserved by the host: ' + ref,
+             {'ref': ref})
+
+
+def parsevalue(value):
+    """Values parse as JSON, FALLING BACK TO STRING - so `8080` is a
+    number, `true` is a boolean, `{"a":1}` is a map, and `hello` is the
+    string it looks like rather than a parse error.
+
+    `parse_constant` REFUSES PYTHON'S JSON EXTENSIONS. `json.loads`
+    accepts `NaN`, `Infinity` and `-Infinity`, which are not JSON and
+    which `JSON.parse` rejects - so an environment variable spelled
+    `NaN` became a float here and stayed the string `'NaN'` in every
+    other port. The model has one answer per input; this is not the
+    place Python gets to be more generous."""
+    try:
+        return json.loads(value, parse_constant=_notjson)
+    except Exception:
+        return value
+
+
+def _notjson(name):
+    raise ValueError('not JSON: ' + name)