Interface

Ecmascript module loader for responsible command and control. 2024 Websites have become humanly unmaintainable. No wonder artificial boilerplate is sweeping the industry. Angular, React, Vue, Svelte, Astro, NextJS, NestJS, Commonjs, Typescript, Flow, JSX, NPM, pNPM, Yarn, Bun, Deno, Tailwind, GraphQL, a list without end. The javascript platform has been increasingly convoluted by non-standard syntactic variations, not to mention semantic mayhem in its ecosystem, requiring growing amounts of configuration to know and maintain. Even when these have merit (static analysis, optimization), they are at the expense of javascript's freedom and flexibility, which could provide these capabilities natively. To make matters worse, package managers have long obscured configurations of external modules, contributing to overengineering on the web, and rendering unreadable a language that could as well be distributed in source format (so to servers as to browsers). Does javascript really have to be this complicated?

Take Command

Since the arrival of loader commands in the Ecmascript specification and their implementation in Node.js (version 16), volatile dialects can finally be standardized dynamically, without a need for external configurations or a new platform trying to contain this heterogeneity (UMD, Deno, Bun). First things first: modules consist of imported, exported and internal declarations. Procedural statements are allowed due to javascript's lack of an interface to access modules otherwise. Interface corrects this with a single procedure that accesses their declarations with arguments provided on a command line. Take a simple module exporting a function to cumulate numbers:

 export function sum(...context)
{// cumulate context values. 
 return context.flat().reduce((sum,value)=>sum+(Number(value)||0),0);
}

/Blik_2023_inference.js/module/namespace/sum

To invoke it, you wouldn't want to include a new procedure for every specific use case. Merging Interface among your files, it will infer them dynamically from specification on the command line:

 git init;
 git remote add interface https://github.com/blikest/interface;
 git checkout interface/stable .;

 node()
{version=$0;
 release=node-v$version-$(uname|tr '[:upper:]' '[:lower:]')-$([[ $(uname -m) -eq aarch64 ]] && echo "arm64" || uname -m );
 curl -O https://nodejs.org/download/release/v$version/$release.tar.gz;
 tar xf $release.tar.gz -C . --strip-components=2 $release/bin/node;
 rm $release.tar.gz;
 for command in node;do alias $command=$(pwd)/$command; done;
 echo " to remove: rm node && unalias node;"
}
 node 22.7.0;

 node ./Blik_2023_interface.js ./Blik_2023_inference.js sum 1 2 3;

Without a command to infer, it will expose its own declarations for procedural use. Grab a terminal, you might need it later:

 node ./Blik_2023_interface.js;

 ❯ locate("inference/sum"); // ["./Blik_2023_inference.js","sum"]
 ❯ access("./Blik_2023_inference.js","string"); // "..."
 ❯ load("./Blik_2023_inference.js"); // "..."
 ❯ interpret("...","./Blik_2023_inference.js"); // SourceTextModule

command("./Blik_2023_inference.js","sum",1,2,3);

Take Control

...of Conditions

: A command line is only one of many contexts a module may be loaded in, so the actual inference procedure depends on a specific set of their conditions. From the inside, modules have two pieces of information available about their external context: the "import" command carrying a

{meta:{url}}

object with their own address, and the "global" object carrying peculiar others:

{process}

indicating Node,

{window}

a browser, or

{imports}

a manually specified context. After importing some general abstractions for syntax and semantics from the Meta and Inference modules, Interface uses these to derive its internal context of conditions. Its own name, location and protocol promptly from the former, then the indicated client agent (

{node,browser,virtual}

) from the latter, along with corresponding language features (

{assertions,attributes,json}

) and command line options (

{loader,offload,inspected}

). Interpreter and thread rank are importable facilities of Node.

 import {modular,measure,produce,construct,deduce,zap,induce,stash,decide,note,collect,search,merge,prune,route,record,remember,tally,rotate,cede,unit,lift,push,sum,same,are,has,promise,pass,slip,something,observe,functor,describe,expect,control,trace,array,compound,simple,revert,rank,tether,differ,whether,either,when,each,drop,swap,crop,infer,buffer,is,not,plural,numeric,binary,basic,match,wait,string,defined,minor,compose,combine,exit,clock,major,colors,skip,flip,debug,extract} from "./Blik_2023_inference.js";
 import {file,folder,url,relate,cookie,path,parser,parse,sanitize,serialize,exports,reexport,mime,coordinates,records} from "./Blik_2023_meta.js";

 export var {protocol,host,pathname:address}=new URL(import.meta.url);
 export var name=file(address);
 export var location=folder(address);
 export var remote=protocol==="http:";

 export var {loader,import:offload,inspect:inspected}=flags(globalThis.process);
 export var agent=merge({virtual:typeof imports!=="undefined"}
,globalThis.process?.versions
?prune.call(globalThis.process.versions,({1:value})=>string(value)?Number(value.match(/(\.{0,1}\d+){1,2}/)?.[0]):value)
:version(globalThis.window.navigator));
 export var features=feature(agent);
 export var interpreter=agent.node&&await import("vm").then(search(["Module"]));
 export var thread=agent.node&&await import("worker_threads").then(infer("isMainThread"))?0:1;
/Blik_2023_interface.js

TypeError: name.split is not a function at attribute (file:///home/ranger/jsrebels/Blik_2023_fragment.js:165:28) at attach (file:///home/ranger/jsrebels/Blik_2023_fragment.js:124:27) at unit.infer (file:///home/ranger/jsrebels/Blik_2023_inference.js:340:49) at infer(attach,20,SVGSVGElement,"http://www.w3.org/19…",undefined,HTMLSpanElement) (file:///home/ranger/jsrebels/Blik_2023_inference.js:207:7) at file:///home/ranger/jsrebels/Blik_2023_inference.js:456:68 at induce(functor) (file:///home/ranger/jsrebels/Blik_2023_inference.js:156:77) at test (file:///home/ranger/jsrebels/Blik_2023_inference.js:456:90) at file:///home/ranger/jsrebels/Blik_2023_inference.js:456:76 at induce(functor) (file:///home/ranger/jsrebels/Blik_2023_inference.js:156:77) at test (file:///home/ranger/jsrebels/Blik_2023_inference.js:456:90) Using Interface directly (and without the interpreter condition requiring the unstable --experimental-vm-modules option) as we did to access the sum function will have it only use this external context, but every import command creates a new internal one that may require our intervention too. Getting to specify Interface as a loader module for Node will have it intercept these contexts with controlled procedures:

 node16 --loader=./Blik_2023_interface.js ./haverbeke_2012_acorn.js;
 node20.2 --import 'data:text/javascript;import("module").then(({register})=>register("./Blik_2023_interface.js",{parentURL:pathToFileURL("./")}));' ./haverbeke_2012_acorn.js;
 node20.7 --import=./Blik_2023_interface.js ./haverbeke_2012_acorn.js;
 node21.1 --import=./Blik_2023_interface.js --experimental-detect-module ./haverbeke_2012_acorn.js;

Module detection introduced and unflagged in 21.1 and 22.7 fails to detect modules with eg. export statements far in the file, so a classic package.json entry may still be needed to ensure module syntax: cat package.json 2>/dev/null || echo {} | jq '.type="module"' > package.json; With the "import" condition, Interface "offloads" this module loading to a secondary thread where it registers itself explicitly from the primary one. To this end, a swarm record and the subscribe and message commands are borrowed from a generic worker module definition that allow them to send and receive command delegation to and from each other after initialization.

 export var worker=
 {imports:
 {"/Blik_2023_inference.js":["","revert","compose","combine","drop","collect","infer","buffer","is","string","note","exit","slip","differ","observe"]
 }
 ,exports:
 {name:"anonymous"
 ,subscribe(peer,label)
{// receive commands from ./delegate. 
 if(swarm[label])
 return console.warn("Worker "+name+" already subscribed to a peer with label: "+label);
 return observe.call(swarm[label]=peer,{message,error(fail){exit(label,fail)}}).postMessage("Worker "+name+" subscribed \nto commands from "+label);
},unsubscribe(label)
{// stop receiving commands. 
 if(!swarm[label])
 return console.warn("Worker "+name+" not subscribed to a peer with label: "+label);
 return observe.call(swarm[label],{message,error(fail){exit(label,fail);}},false).postMessage("Worker "+name+" unsubscribed \nof commands from "+label);
},command
 ,message({data})
{if(!Array.isArray(data))
 return console.log(data);
 let [type,id,term,...context]=data;
 if(type!=="command")
 return;
 let inference=infer(...string(term)
?[differ(command.bind(import.meta.url)),import.meta.url,term,...context]
:[compose(recompose,compose,infer("call",...context)),term,import.meta.url]);
 compose
(buffer(inference,crop(1))
,combine
(compose(slip("event",id),collect)
,compose(collect,tether(search,compose(drop(1),search(1),match({constructor:{name:either(is("ArrayBuffer"),is("MessagePort"),is("FileHandle"))}})),false,construct),Object.values)
),slip(this),"postMessage"
)();
}},procedures:{async initialize()
{var swarm={};
 var peer=this||globalThis.self||await import("worker_threads").then(({parentPort})=>parentPort);
/Blik_2023_interface.js

Once intercepted, the probe and prepend commands will help imports locate modules with unspecified attribution (author and year), while the idempotent peer record provide access to remote protocols. With the interpreter condition, the Module command composes all 3 loading stages explicitly: locate, access and interpret. Without it, Node's import procedure limits control to the first two by the names "resolve" and "load", but command still extends them with custom context specification and inference. The record of modules will store respective

{resolution,module,imports}

references by relative specifier for immediacy. In order to extend itself further, location is applied in isolation for an illustratively unattributed sources module, specifying an importmap to remote addresses.

 subscribe(peer,"default");
}}
 };
 export var {swarm={},subscribe,message}=worker.exports;

 export var authors=["Blik"];
 export var years=[2019,new Date().getFullYear()].reduce((min,max)=>
 Array.from({length:max-min},(year,index)=>max-index));
 export var probe=agent.node?compose(command.bind(import.meta.url,"path","resolve"),command.call(import.meta.url,"fs","promises"),flip,"stat"):command.bind(import.meta.url);
 export var prepend=either(...
 [authors,years].reduce((authors,years)=>authors.flatMap(author=>years.map(year=>
 "/"+author+"_"+year))).map(prefix=>compose
(/^([^\/])/,"./$1","replace",infer(url,address),"pathname",combine(folder,file),drop(1,1,prefix,"_"),"concat",pass(probe)
)),drop());
 export var peer=remember
(compose(drop(1,2),"Agent",{timeout:5*60*1000},command.bind(import.meta.url))
,protocol=>protocol
);

 export var Module=interpreter?compose(stash(compose(tether(locate),true,access)),drop(1),rotate(1),drop(2,0,interpret)):tether(command);
 export var modules={}; // tracking imports in /resolve and /load. 
 export var [sources]=await locate("sources.json");
 export var importmap=await Module.call(import.meta.url,sources,"default");

 if(agent.node&&!agent.virtual&&!remote&&!thread&&!loader)
 // --import flag offloads loader commands to separate thread unlike 
 // --loader, where context is available directly on the primary thread. 
 offload
?await register(address).then(async function initialize(loader)
{// reciprocate subscription to commands from loader thread. 
 subscribe(loader,"loader");
 if(!inspected)return;
 let {debugPort:port}=globalThis.process;
 await delegate.call(loader,"inspect",port+1);
 await inspect(port);
)(module)
/Blik_2023_interface.js

A non-virtual, local Node client agency without the "loader" option then is the condition for the inference procedure, called indirectly if offloading was specified. Registration in that case replicates the worker definition's corresponding commission command, observing a message channel on its near end until initialize reports subscription from its far one. In commission this is a re-subscription command since workers have procedural initialization subscribing to a default channel, but here initialization itself is being delegated with the controlled one. After registration, the loader thread anticipates a reciprocal subscription from the primary thread likewise "initializing" itself. Inspect finally re-binds inspector protocols in sequence to leave the primary thread's panel visible. Inference concludes by polling the loader thread for pending tests or resources.

:revert.call
(command.call(import.meta.url,"repl","start",{useGlobal:true})
,(exit,fail,line)=>observe.call(line,{exit})
);
};

 export function register(address)
{// register loader thread. 
 if(agent.node>=25.9)
 return command.call(import.meta.url,"module","registerHooks",{resolve,load});
 return compose.call
("worker_threads",command.bind(import.meta.url),tether(search,["MessageChannel"]),[],Reflect.construct
,address,revert(function register(resume,onerror,{port1:near,port2:far},address)
{// observe channel until /initialize reports subscription from its far end from the loader thread. 
 observe.call(near,{message({data}){note.call(2,data),resume(this);},onerror,messageerror:onerror},{once:true});
 command.call(import.meta.url,"module","register",address,import.meta.url,{data:far,transferList:[far]});
})
);
};

 export async function commission(module,peer)
{let ephemeral=functor(module);
 if(ephemeral&&!module.name)
 throw Error("Can't create ephemeral worker for anonymous function.");
 let address=string(module)?module:compose.call
(ephemeral?{exports:{[module.name]:module}}:module,worker,0,merge
,tether(prune,([field,value])=>field!=="imports"?value
:Object.fromEntries(Object.entries(value).map(([field,value])=>
 [protocol+"//"+location+field,value]))),"module",serialize,...agent.node
?[Buffer.from,"base64","toString","data:text/javascript;base64,",flip,"concat",collect,slip(URL),Reflect.construct]
:[{type:"text/javascript"},collect,slip(Blob),Reflect.construct,URL.createObjectURL]
);
 let name=string(module)?module:functor(module)?module.name:module.exports?.name;
 let thread=await compose.call
(agent.node?import("worker_threads"):{Worker},search("Worker")
 // https://nodejs.org/api/esm.html#esm_loaders 
/Blik_2023_interface.js

...of Location

: By standard, modules are identified by the protocol (data, file, http or node), domain and full path of their universal resource locator (URL), that a 'dot' can abbreviate relative to a target context. Node already diverges from this by allowing npm's package identifiers to be resolved through obscure folder and manifest navigation, and simply rejecting module specifiers that aren't found - necessitating package management in the first place. To restore respect for the standard, Interface forgets the notion of a package, and instead extends "resolution" with its location of attribution prefixes and importmap entry points if declared for the given specifier, downloading, standardizing and redirecting to them before access.

{"haverbeke_2012_acorn.js":{"https://github.com/acornjs/acorn":{"8.9.0":["acorn/src/index.js"]}},"davidbonnet_2015_astring.js":{"https://github.com/davidbonnet/astring":{"v1.8.6":["src/astring.js"]}},"Harris_2015_rollup.js":{"https://github.com/rollup/rollup/src cli browser":{"v3.28.1":["src/node-entry.ts",{"syntax":"typescript","alias":{"package.json":"./Harris_2015_rollup/0/package.json","acorn":"./haverbeke_2012_acorn.js","locate-character":"./Harris_2016_locate_character.js","acorn-import-assertions":"./xtuc_2020_acorn_importassertions.js","@rollup/pluginutils":"./Harris_2015_pluginutils.js","magic-string":"./Harris_2014_magic_string.js","acorn-walk":"./haverbeke_2012_acorn_walk.js","flru":"./lukeed_2019_flru.js","is-reference":"./Harris_2016_is_reference.js","@jridgewell/sourcemap-codec":"./jridgewell_2015_sourcemap_codec.js","builtin-modules/static":"./sindresorhus_2015_builtin_modules_static.js","colorette":"./jorgebucaran_2018_colorette.js","chokidar":"./paulmillr_2012_chokidar.js"}}]}}}

This sample for example maps the general parser (acorn) and serializer/bundler (astring and rollup) module that Interface itself imports to standardize dialects in the "load" stage when needed. When importing these for the first time, standardization of their own source is performed by them being accessed from right there, before the idempotent bundles they produce for access replace the arbitrarily structured sources. Node passes a context object to all imports containing the peer module's identifier implicitly and some "attributes" specifiable explicitly (mostly

{type:"json"}

), which command inverts to be explicit and implicit respectively (the explicit

{peer}

attribute being pruned later as Node's internal resolution rejects it). The implicit identifier's lack indicates the primary import to be re-delegated for indirect inference. Since the module specifier can be relative, its absolute identifier is established given that of its peer module, and a relative path to both from Interface (its folder reference as peer from command indicating omission promptly resolves to an empty relation). These are then used to probe the record of modules for a resolution precedent, or attempt Node's internal resolution, latter retried with extensions if a folder was hit, location in case attribution was missing, acquisition or alias if an importmap scope is identified from the specifier path (cases to be merged into location when interpretation is stabilized). As acquisition does import modules from source before bundling, this scope is also passed on to access as

{format}

along with

{url}

in the resolution object. Bundling achieves the same while having the source definition in scope for all resolutions and transforms, only offsets external aliases to be relative to the target bundle, and thus omited from it. Finally it is also extended with

{time}

for history and

{shortCircuit}

to instruct Node not to call its internal resolution anymore, and merged into the record of modules as

{relative:{resolution},relation:{imports:new Set([relative])}}

. TypeError [ERR_INVALID_RETURN_PROPERTY_VALUE]: Expected a URL string to be returned for the "url" from the "node:internal/modules/esm/resolve 'resolve'" hook but got type string ('file://file:///home/range...'). at Hooks.resolve (node:internal/modules/esm/hooks:272:15) at async handleMessage (node:internal/modules/esm/worker:199:18){background:transparent;max-width:90%;margin:auto;border-radius:.5em; border:2px dashed

...of Access

: While thus evoked during the acquisition stage of remote resolution to persist a standard bundle, an import may still locate a foreign syntax to access when specified directly. The context object will contain a format field that Internal resolution would have set to a native format, which profile verifies for "json", "builtin" and "module", and extends to "typescript" and "shader" based on suffix. An importmap entry will have been set by alias if so resolved, or acquisition may have passed it directly. These can contain multiple source definitions that are merged, and a "sparse" path relative to the relevant one is established. Edits relative to this path are then filtered, and applied between access and a patriation process of parsing, sanitization (standardization) and re-serialization. Before conclusion, check delegates a test command to the primary thread to traverse the loaded module's "tests" declaration mapping their namespace to compositions of a context with

(...route,buffer(scope?tether(term):term),...terms,condition)

. TypeError [ERR_INVALID_RETURN_PROPERTY_VALUE]: Expected a URL string to be returned for the "url" from the "/home/ranger/jsrebels/Blik_2023_interface.js 'resolve'" hook but got type string ('file://file:///home/range...'). at Hooks.resolve (node:internal/modules/esm/hooks:272:15) at async handleMessage (node:internal/modules/esm/worker:199:18){background:transparent;max-width:90%;margin:auto;border-radius:.5em; border:2px dashed

...of Interpretation

: Node's internal interpretation is not customizable, but the interpreter option allows the explicit, recursive creation of module contexts, and using location and access directly. Since module definitions like worker are serialized dynamically, this is required if they are to be used in Node. TypeError [ERR_INVALID_RETURN_PROPERTY_VALUE]: Expected a URL string to be returned for the "url" from the "/home/ranger/jsrebels/Blik_2023_interface.js 'resolve'" hook but got type string ('file://file:///home/range...'). at Hooks.resolve (node:internal/modules/esm/hooks:272:15) at async handleMessage (node:internal/modules/esm/worker:199:18){background:transparent;max-width:90%;margin:auto;border-radius:.5em; border:2px dashed

Take Responsibility

The rest of Interface contains facilities to stream, list, persist or purge files, spawn or recompose procedures. To see it all visually, its loaded semantics can be represented as a hierarchy with the default function of the Network module. Notable is the infrastructure function that prunes the record of modules for imports and resolution timestamps, again representable as a network. We may glean that Interface was commanded to run the expose function of the Port module, with the Form and Protocol modules as its arguments. TypeError: Cannot convert undefined or null to object at Function.assign (<anonymous>) at chart (file:///home/ranger/jsrebels/Blik_2024_network.js:483:16) at induce(bound apply) (file:///home/ranger/jsrebels/Blik_2023_inference.js:156:77) at file:///home/ranger/jsrebels/Blik_2023_inference.js:165:9 at reduce(chart) (file:///home/ranger/jsrebels/Blik_2023_inference.js:156:77) at induce(reduce(chart)) (file:///home/ranger/jsrebels/Blik_2023_inference.js:156:77) at file:///home/ranger/jsrebels/Blik_2023_inference.js:165:9 at deduce(deduce(deduce(deduce(deduce(deduce(deduce(deduce(deduce(unit,reduce(functor),0,Array),reduce(reduce(unit)),1,Array),reduce(stash(produce(matrix,Array,record))),2,Array),reduce(drop(Infinity,1,produce(rotate(1),drop(2,0,merge)))),3,Array),reduce(combine(functor,drop(1))),4,Array),reduce(reduce(unit)),5,Array),reduce(combine(spread,drop(1))),6,Array),reduce(reduce(unit)),7,Array),reduce(chart),8,Array) (file:///home/ranger/jsrebels/Blik_2023_inference.js:156:7) at file:///home/ranger/jsrebels/Blik_2023_inference.js:165:27 at deduce(deduce(deduce(deduce(deduce(deduce(deduce(deduce(deduce(deduce(unit,reduce(functor),0,Array),reduce(reduce(unit)),1,Array),reduce(stash(produce(matrix,Array,record))),2,Array),reduce(drop(Infinity,1,produce(rotate(1),drop(2,0,merge)))),3,Array),reduce(combine(functor,drop(1))),4,Array),reduce(reduce(unit)),5,Array),reduce(combine(spread,drop(1))),6,Array),reduce(reduce(unit)),7,Array),reduce(chart),8,Array),reduce(simulate),9,Array) (file:///home/ranger/jsrebels/Blik_2023_inference.js:156:7){height:1000px} When the module loader runs on a second thread, infrastructure actually needs to be delegated to access its loaded modules there. More importantly, these representations produced by the Network module are not just raw text, but physical interfaces themselves: nodes can be zoomed, collapsed, expanded or even added and removed. As a matter of fact, this whole document has been a physical interface: you've scrolled, interpretted colors and shapes, clicked, typed, perhaps watched a video. Its source text is in the Blik_2023_interface file, but inferring this representation of it with a simple '

node interface/access ./Blik_2024_interface | node fragment/media

' command, or that of networks with '

node interface/delegate infrastructure | node network

' would at best produce a static version of them. Like Interface for javascript modules, Browsers provide a stable, standard (however bloated) platform for such hypermedia, using a "request" protocol called Hypertext Transfer (HTTP). The Port module exposes an interface for the command of these requests, extending our control beyond the command line. Uninstall external modules bundled based on their source definitions:

 for file in $(cat *sources.json | jq keys[] --raw-output);do rm -rf $file $(echo $file | sed 's/\.js$//');done

or, if you're sure every file you need is committed on their respective remotes:

 rm -rf $(git check-ignore *);