agnostics 0.0.2 → 0.0.4

package/lib/bases/_BaseOnCall.js

@@ -0,0 +1,41 @@
+//////////////////////////////////////////
+//                                      //
+//                                      //
+//                BASE                  //
+//                                      //
+//                                      //
+//////////////////////////////////////////
+
+import { CreateLogger } from 'agnostics/logger'
+const { ERR } = CreateLogger( import.meta.url )
+
+export class BaseOnCall {
+	
+	className = 'Base'
+
+	$listenerCbs = {}
+
+	constructor() {}
+
+	$call( name, res ) {
+		const alls = ['all', '*']
+		const includesKey = Object.keys(this.$listenerCbs).includes(name)
+		if (!includesKey) return ERR(`NONEXISTENT:`, name)
+		for (const callback of this.$listenerCbs[name]) callback(res)
+		for (const all of alls) {
+			if (this.$listenerCbs[all]) {
+				for (const callback of this.$listenerCbs[all]) callback(name, res)
+			}
+		}
+
+	}
+
+	on( name, callback ) {
+		const isAll = name === 'all' || name === '*'
+		const includesKey = Object.keys(this.$listenerCbs).includes(name)
+		if (!includesKey && !isAll) return ERR(`NONEXISTENT:`, name)
+		if (!this.$listenerCbs[name]) this.$listenerCbs[name] = []
+		this.$listenerCbs[name].push(callback)
+	}
+
+}

package/lib/bases/_BasePrompt.js

@@ -0,0 +1,33 @@
+//////////////////////////////////////////
+//                                      //
+//                                      //
+//             BASE PROMPT              //
+//                                      //
+//                                      //
+//////////////////////////////////////////
+
+import { CreateLogger } from 'agnostics/logger'
+const { SAY, HMM, ERR, YAY } = CreateLogger( import.meta.url )
+
+import { BaseOnCall } from './_BaseOnCall.js'
+
+export class BasePrompt extends BaseOnCall {
+
+	className = 'BasePrompt:BaseOnCall'
+
+	constructor( ) {
+		super()
+	}
+
+	ask( config = { message: '', schema: {} } ) {
+
+		HMM('ASK NOT IMPLEMENTED:', this.className)
+		const { message, schema } = config
+		return new Promise( resolve => {
+			const res = {}
+			for (const [key,value] of Object.entries(schema)) res[key] = true
+			resolve(res)
+		})
+	}
+}
+

package/lib/bases/_BaseRemote.js

@@ -0,0 +1,118 @@
+//////////////////////////////////////////
+//                                      //
+//                                      //
+//             BASE REMOTE              //
+//                                      //
+//                                      //
+//////////////////////////////////////////
+
+/*
+	
+	CLASSES MUST HAVE:
+
+	1) single config on constructor
+	2) some way to post / receive
+	3) 
+
+
+*/
+
+import { CreateLogger } from 'agnostics/logger'
+const { SAY, ERR, YAY, HMM, HUH } = CreateLogger( import.meta.url )
+
+import { BaseOnCall } from './_BaseOnCall.js'
+
+export class BaseRemote extends BaseOnCall {
+
+	className = 'BaseRemote:BaseOnCall'
+
+	$methodReqs = {
+	}
+
+	constructor() {
+		super()
+		this.isIniting = true
+	}
+
+	construct() {}
+
+	getMethodListenerNames() {
+		let methodNames = new Set()
+		let current = this
+		const exclude = ['getMethodListenerNames', 'construct', 'on']
+
+		do {
+			Object.getOwnPropertyNames(current).forEach(prop => {
+				if (prop === 'constructor') return
+				const desc = Object.getOwnPropertyDescriptor(current, prop)
+				if (!desc || prop[0] === '$' || exclude.includes(prop)) return
+				if (
+					typeof desc.value === 'function' ||
+					typeof desc.get === 'function' ||
+					typeof desc.set === 'function'
+				) {
+					methodNames.add(prop)
+				}
+			})
+
+			current = Object.getPrototypeOf(current)
+		} while (current !== null && current !== Object.prototype)
+
+		methodNames = [...methodNames].sort()
+		const listenerNames = Object.keys(this.$listenerCbs || {})
+		return { methodNames, listenerNames }
+	}
+
+	$initMethodsAndListeners( methodNames, listenerNames ) {
+
+		// ========= METHODS =========
+
+		for (const name of methodNames) {
+			this.$methodReqs[name] = []
+
+			this[name] = (...req) => {
+
+				const type = 'method'
+				const index = this.$methodReqs[name].length
+				this.$sendRequest( type, name, req, index ) 
+				return new Promise( resolve => {
+					this.$methodReqs[name].push( resolve )
+				})
+			}
+		}
+
+		// ========= CALLBACKS =========
+
+		for (const listenerCb of listenerNames) {
+			this.$listenerCbs[listenerCb] = []
+		}
+
+		// ========= READY =========
+
+		YAY('REMOTE:', this.className)
+
+		HUH('➔ METHODS:', methodNames.join(' '))
+		HUH('➔ LISTENERS:', listenerNames.join(' '))
+		this.isIniting = false
+	}
+
+	$handleResponse( type, index, name, res ) {
+
+		if (type === 'method') {
+			const resolver = this.$methodReqs[name]?.[index]
+			if (!resolver) {
+				ERR(`REMOTE NO RESOLVER:`, name, index)
+			} else {
+				this.$methodReqs[name][index](res)
+				this.$methodReqs[name][index] = null
+				const allDone = this.$methodReqs[name].every(item => item === null)
+				if (allDone) this.$methodReqs[name] = []
+			}
+		}  else if (type === 'listener') {
+			this.$call( name, res )
+		} else {
+			HMM(`UNKNOWN RESPONSE:`, {type,name})
+		}
+	}
+
+}

package/lib/bases/index.js

@@ -0,0 +1,12 @@
+//////////////////////////////////////////
+//                                      //
+//                                      //
+//                BASES                 //
+//                                      //
+//                                      //
+//////////////////////////////////////////
+
+
+export * from './_BaseOnCall.js'
+export * from './_BasePrompt.js'
+export * from './_BaseRemote.js'

package/lib/helpers/_Yargs.js

@@ -10,45 +10,17 @@ import { Obj, isArr, isNum, isBool } from '../inputs/index.js'
 import { NormaliseAccept } from './_Parsers.js'
 
 import { CreateLogger } from '../logger/index.js'
+import path from 'path'
 const { SAY, ERR, HMM, HUH } = CreateLogger( import.meta.url )
 
 
-async function LoadYargs() {
-
-	if (!globalThis.yargsLib || !globalThis.yargsHideBin) {
-		try {
-			globalThis.yargsLib = (await import ('yargs')).default
-			globalThis.yargsHideBin = (await import ('yargs/helpers')).hideBin
-			return true
-		} catch(err) {
-			return ERR(`YARGS UNAVAILABLE`, err)	
-		}
-	}
-}
-
-async function LoadGlobby() {
-
-	if (!globalThis.globbyLib || !globalThis.pathExtname) {
-		try {
-			globalThis.globbyLib = (await import ('globby')).globby
-			globalThis.pathExtname = (await import ('path')).extname
-			return true
-		} catch(err) {
-			return ERR(`GLOBS UNAVAILABLE`, err)	
-		}
-	}
-}
 
 async function GetYargsFiles( value, extensions ) {
 
 	try {
-
-		if (!(await LoadGlobby())) return []
-
-
 		const anything = (extensions.length === 0 || extensions.includes('*'))
 
-		const found = await globalThis.globbyLib(value, {
+		const found = await globalThis.Yargs(value, {
 			onlyFiles: true,
 			expandDirectories: false,
 			caseSensitiveMatch: false
@@ -56,7 +28,7 @@ async function GetYargsFiles( value, extensions ) {
 
 		const exts = extensions.map( ext => ext.toLowerCase().replaceAll('.',''))
 		const files = anything ? found : found.filter(file => {
-			const ext = globalThis.pathExtname(file).replaceAll('.','')
+			const ext = path.extname(file).replaceAll('.','')
 			return exts.includes(ext)
 		})
 
@@ -111,14 +83,17 @@ export function ConvertYargsProperty( def, override = {} ) {
 
 	const array = def.gui == 'files' || isArr(def.type)
 
-	return Object.assign({
+	const yargsDef = Object.assign({
 		array,
 		describe: def.description,
 		type: GetYargsType(def.type),
-		coerce: def.oncheck,
+		coerce: def.onsend,
 		default: def.default,
-		accept: NormaliseAccept( def.accept )
+		accept: NormaliseAccept( def.accept ),
+		choices: def.enum
 	}, override)
+
+	return yargsDef
 }
 
 
@@ -136,7 +111,7 @@ export function YargsProcessWorkaround() {
 
 export class YargsCommand {
 
-	command = '$0'
+	command = null
 	description = 'N/A'
 	version = 'N/A'
 	positionals = {}
@@ -148,7 +123,6 @@ export class YargsCommand {
 
 	constructor( { positionals, options = {}, description = 'N/A', version = 'N/A' } ) {
 
-
 		this.description = description
 		this.version = version
 
@@ -189,15 +163,12 @@ export class YargsCommand {
 
 	async run( runCallback = async yargsData => {} ) {
 
-		if (!(await LoadYargs())) return
 
-		YargsProcessWorkaround()
-
-		const args = globalThis.yargsHideBin( process.argv )
-		const instance = globalThis.yargsLib( args )
+		const args = globalThis.YargsBin( process.argv )
+		const instance = globalThis.Yargs( args )
 
 		instance.command(
-			this.command,
+			'$0 '+ this.command + ' [run]', // hack
 			this.description,
 			yargsData => {
 				const positionals = Object.entries(this.positionals)
@@ -270,13 +241,8 @@ export class YargsCLI {
 
 	async run( runCallback = async (cmdKey, yargsData) => {} ) {
 
-		if (!(await LoadYargs())) return
-
-		// YargsProcessWorkaround()
-
-
-		const args = globalThis.yargsHideBin( process.argv )
-		const instance = globalThis.yargsLib( args )
+		const args = globalThis.YargsBin( process.argv )
+		const instance = globalThis.Yargs( args )
 
 		for (const [cmdKey, cmdObj] of Object.entries(this.$commands)) {
 

package/lib/index.js

@@ -6,6 +6,9 @@
 //                                      //
 //////////////////////////////////////////
 
+import { fileURLToPath } from 'node:url'
+import { dirname } from 'node:path'
+
 export * from './helpers/index.js'
 export * from './inputs/index.js'
 export * from './specification/index.js'

package/lib/loaders/_Loaders.js

@@ -0,0 +1,62 @@
+//////////////////////////////////////////
+//                                      //
+//                                      //
+//               LOADERS                //
+//                                      //
+//                                      //
+//////////////////////////////////////////
+
+import { CreateLogger } from 'agnostics/logger'
+const { YAY, ERR, SAY } = CreateLogger( import.meta.url )
+
+import path from 'path'
+import fs from 'fs/promises'
+import { pathToFileURL } from 'node:url'
+
+export async function LoadDep( name, url ) {
+
+	const [ base, stem ] = url.split('.')
+	let mod
+
+	if (!globalThis[base]) {
+		try {
+			mod = (await import (base))
+		} catch(err) {
+			try {
+				const pkgDir = path.join(process.cwd(), 'node_modules', base)
+				const pkgJsonPath = path.join(pkgDir, 'package.json')
+				const pkgJson = JSON.parse(await fs.readFile(pkgJsonPath))
+				let entry = pkgJson.main || pkgJson.module || 'index.js'
+				if (pkgJson.exports && pkgJson.exports['.']) {
+					const exportIndex = pkgJson.exports['.']?.index || pkgJson.exports['.']
+					entry = exportIndex.replace(/^\.\//, '')
+				}
+				const fullEntryPath = path.join(pkgDir, entry)
+				const entryUrl = pathToFileURL(fullEntryPath).href
+				mod = (await import (entryUrl))
+			} catch(err) {
+				return ERR(`FAIL:`, name, err.message)	
+			}
+		}
+		if (stem) mod = mod[stem]
+		globalThis[name] = mod
+		YAY(`LOADED:`, name)
+		return globalThis[name]
+	}
+}
+
+export async function LoadWebview() {
+	return await LoadDep('Webview', '@webviewjs/webview.Application')
+}
+
+export async function LoadYargs() {
+
+	const YargsLib = await LoadDep('Yargs', 'yargs.default')
+	const YargsBin = await LoadDep('YargsBin', 'yargs/helpers.hideBin')
+
+	return { YargsLib, YargsBin }
+}
+
+export async function LoadGlobby() {
+	return await LoadDep('Globby', 'globby.globby')
+}

package/lib/loaders/index.js

@@ -0,0 +1,9 @@
+//////////////////////////////////////////
+//                                      //
+//                                      //
+//               LOADERS                //
+//                                      //
+//                                      //
+//////////////////////////////////////////
+
+export * from './_Loaders.js'

package/lib/specification/_Properties.js

@@ -8,6 +8,21 @@
 
 export const Properties = {
 
+	// --------- EVENTS ---------
+
+	onsend: {
+		description: 'callback for checking value before sending', 
+		matches: [ 'oncheck', 'validate', 'coerce', 'check']
+	},
+	onreceive: {
+		description: 'callback for checking value when received', 
+		matches: [ 'onreceive', 'validate', 'coerce', 'check']
+	},
+	onupdate: {
+		description: 'callback for updated value', 
+		matches: [ 'onupdate', 'update', 'change', 'onchange']
+	},
+
 	// --------- DEFINITION ---------
 
 	type: {
@@ -68,14 +83,6 @@ export const Properties = {
 		description: 'property can only be read',
 		matches: ['readonly', 'ro']
 	},
-	oncheck: {
-		description: 'callback for checking value', 
-		matches: [ 'oncheck', 'validate', 'coerce', 'check']
-	},
-	onupdate: {
-		description: 'callback for updated value', 
-		matches: [ 'onupdate', 'update', 'change', 'onchange']
-	},
 
 	// --------- STRUCTURAL ---------
 

package/lib/targets/_InquirerTarget.js

@@ -0,0 +1,15 @@
+
+
+// @inquirer/prompts
+
+async function LoadInquirer() {
+
+	if (!globalThis.inquirerLib) {
+		try {
+			globalThis.inquirerLib = (await import ('inquirer')).inquirer
+			return true
+		} catch(err) {
+			return ERR(`GLOBS UNAVAILABLE`, err)	
+		}
+	}
+}

package/lib/targets/_WebviewTarget.js

@@ -0,0 +1,182 @@
+//////////////////////////////////////////
+//                                      //
+//                                      //
+//            WINDOW TARGET             //
+//                                      //
+//                                      //
+//////////////////////////////////////////
+
+import { CreateLogger } from 'agnostics/logger'
+const { SAY, ERR, YAY, HUH, HMM } = CreateLogger( import.meta.url )
+import fs from 'node:fs'
+
+import { BaseRemote } from '../bases/_BaseRemote.js'
+
+export const WebviewConfig = {
+
+	app: {
+		controlFlow: 0, // Poll | WaitUntil | Exit | ExitWithCode
+		waitTime: 0, // ms for WaitUntil
+		exitCode: 0, // for ExitWithCode
+	},
+	browser: {
+		resizable: true,
+		title: 'Hello World',
+		width: 800,
+		height: 600,
+		x: null,
+		y: null,
+		contentProtection: false,
+		alwaysOnTop: false,
+		alwaysOnBottom: false,
+		visible: true,
+		decorations: true, // false = borderless/frameless
+		transparent: false, // needs CSS background: transparent
+		visibleOnAllWorkspaces: false,
+		maximized: false,
+		maximizable: true,
+		minimizable: true,
+		focused: true,
+		fullscreen: null // Exclusive | Borderless | null
+	},
+	webview: {
+		enableDevtools: true,
+		incognito: false,
+		userAgent: null,
+		child: false,
+		preload: null,
+		hotkeysZoom: false,
+		theme: 2, // Light | Dark | System
+		clipboard: false,
+		autoplay: false,
+		backForwardNavigationGestures: false
+	},
+	showDevTools: false
+}
+
+const PreloadScript = `
+
+	console.log('[PRELOAD] safe ipc')
+
+	globalThis.gt = globalThis
+
+	gt.postMessage = gt.webkit.messageHandlers.ipc.postMessage || gt.ipc.postMessage || gt.chrome.webview.postMessage
+
+`
+
+
+export class WebviewTarget extends BaseRemote {
+
+	className = 'WebviewTarget:BaseRemote:BaseOnCall'
+
+	$instance = null
+
+	constructor( source, config = {} ) {
+
+		super()
+
+		if (!source) throw Error('NO SOURCE')
+
+		config = { ...WebviewConfig, ...(config || {})}
+
+		const clean = obj => Object.fromEntries(
+			Object.entries(obj).filter(([, v]) => v != null))
+
+		const isUrl = source.startsWith('http') || source.startsWith('www')
+		const isPath = source.startsWith('/')||source.startsWith('.')
+		const isHtml = source.trim().startsWith('<')
+
+		if (isUrl) {
+			config.webview.url = source
+		} else if (isPath && !isHtml) {
+			config.webview.html = fs.readFileSync(source, 'utf8')
+			SAY('READ HTML:', source)
+		} else {
+			config.webview.html = source
+		}
+
+		const appOpts = clean({...WebviewConfig.app, ...config.app})
+		const browserOpts = clean({...WebviewConfig.browser, ...config.browser})
+		const webviewOpts = clean({...WebviewConfig.webview, ...config.webview})
+
+		webviewOpts.preload = PreloadScript
+
+
+		const app = new globalThis.Webview( appOpts )
+		const browser = app.createBrowserWindow( browserOpts )
+		const webview = browser.createWebview( webviewOpts )
+
+		if (config.showDevTools && !webview.isDevtoolsOpen()) webview.openDevtools()
+		if (!config.showDevTools && webview.isDevtoolsOpen()) webview.closeDevtools()
+
+		app.onEvent(event => {
+
+			if (event === 0) {
+				SAY('WINDOW CLOSE REQ:', event)
+				this.$call('closing', 0)
+				browser.close()
+			} else if (event === 1) {
+				SAY('APP CLOSE REQ:', event)
+				this.$call('closing', 1)
+				app.close()
+			} else {
+				SAY('MISC EVENT:', event)
+			}
+		})
+
+		webview.onIpcMessage( message => {
+			SAY('WEBVIEW MESSAGE:', message)
+		})
+
+		this.$instance = { app, browser, webview }
+
+	}
+
+	construct( ...constructArguments ) {
+
+		const { app, browser, webview } = this.$instance 
+
+		const args = constructArguments.map( arg => JSON.stringify(arg) ).join(', ')
+
+		SAY('EVAL')
+		webview.evaluateScript(`
+
+			console.log('EVAL')	
+
+			gt.app = new App( ${args} )
+
+			gt.onIpcMessage = async message => {
+
+				console.log('NEW MESSAGE', message)
+				// const res = await app[name](...req)
+
+				// parentPort.postMessage({
+				// 	type,
+				// 	name,
+				// 	index,
+				// 	res
+				// })
+			}
+
+			app.on('*', (name, res) => {
+
+				console.log('WOOOO', name, res)
+				gt.webkit.messageHandlers.ipc.postMessage('data')
+				gt.ipc.postMessage({
+					type: 'listener',
+					name,
+					res
+				})
+			})
+		`)
+
+		// ========= INIT =========
+
+		return new Promise( resolve => {
+			HMM('INITIIALISE (wait)')
+			this.resolveConstruct = resolve
+			app.run()
+		})
+	}
+
+}

package/lib/targets/index.js

@@ -0,0 +1,9 @@
+//////////////////////////////////////////
+//                                      //
+//                                      //
+//               TARGETS                //
+//                                      //
+//                                      //
+//////////////////////////////////////////
+
+export * from './_WebviewTarget.js'

package/lib/workers/_AutoRunner.js

@@ -0,0 +1,67 @@
+//////////////////////////////////////////
+//                                      //
+//                                      //
+//            AUTO INSTANCE             //
+//                                      //
+//                                      //
+//////////////////////////////////////////
+
+import { workerData, parentPort } from 'worker_threads'
+const { importUrl, importName, constructArguments } = workerData
+
+import { CreateLogger } from 'agnostics/logger'
+const { SAY, ERR } = CreateLogger( import.meta.url )
+import path from 'node:path'
+
+async function RunInstance() {
+
+	// ========= INSTANTIATE =========
+
+	const cwdImportUrl = path.resolve( process.cwd(), importUrl )
+	const imported = await import(cwdImportUrl)
+	const instantiator = imported[importName]
+	if (!instantiator) return ERR('NO INSTANCE:', importUrl, importName)
+
+	// ========= INSTANCE =========
+
+	const instance = new instantiator()
+	await instance.construct( ...constructArguments )
+
+	// ========= REQ / RES =========
+
+	parentPort.on( 'message', async ({type,name,req,index}) => {
+
+		const res = await instance[name](...req)
+
+		parentPort.postMessage({
+			type,
+			name,
+			index,
+			res
+		})
+	})
+
+	// ========= ALL EVENTS =========
+
+	instance.on('*', (name, res) => {
+
+		parentPort.postMessage({
+			type: 'listener',
+			name,
+			res
+		})
+	})
+
+	// ========= INIT METHODS =========
+
+	const methodListenerNames = instance.getMethodListenerNames()
+
+	parentPort.postMessage({
+		name: 'methodListenerNames',
+		res: methodListenerNames
+	})
+
+
+}
+
+RunInstance()

package/lib/workers/_AutoWorker.js

@@ -0,0 +1,136 @@
+//////////////////////////////////////////
+//                                      //
+//                                      //
+//             AUTO WORKER              //
+//                                      //
+//                                      //
+//////////////////////////////////////////
+
+import { CreateLogger } from 'agnostics/logger'
+const { SAY, ERR, YAY, HMM, HUH } = CreateLogger( import.meta.url )
+
+import { Worker } from 'node:worker_threads'
+import { BaseRemote } from '../bases/_BaseRemote.js'
+
+import { fileURLToPath } from 'node:url'
+import path from 'node:path'
+
+// Get the directory of the CURRENT file
+const __filename = fileURLToPath(import.meta.url)
+const _dir = path.dirname(__filename)
+
+// We use a template literal or a joined string that Rollup 
+// can't resolve statically during the build.
+const workerFilename = '_AutoRunner.js'; 
+export const AutoRunnerPath = path.join(_dir, 'workers', workerFilename);
+
+export class AutoWorker extends BaseRemote {
+
+	className = 'AutoWorker:BaseRemote'
+	
+	$worker = null
+
+	$listenerCbs = {
+		error: [],
+		exit: [],
+		online: []
+	}
+
+	importUrl = null 
+	importName = null
+
+	constructor( importPath  ) {
+
+		super() // Base = on / $call pattern
+
+		let [ importUrl, importName ] = importPath.split('?')
+		if (importName === '') importName = 'default'
+
+		this.importUrl = importUrl
+		this.importName = importName
+
+	}
+
+	$sendRequest( type, name, req, index) {
+
+		this.$worker.postMessage({
+			type,
+			name,
+			req,
+			index
+		})
+	}
+
+	construct( ...constructArguments ) {
+
+		const { importUrl, importName } = this 
+
+		this.className = importName + ':' + this.className
+
+		this.$worker = new Worker(
+			new URL('./_AutoRunner.js?worker', import.meta.url).pathname, 
+			{
+				type: 'module',
+				workerData: {
+					importUrl,
+					importName,
+					constructArguments
+				}})
+
+		// ========= MESSAGES =========
+
+		this.$worker.on('message', message => {
+
+			// ========= INIT =========
+
+			if (message.name === 'methodListenerNames') {
+
+				const { methodNames, listenerNames } = message.res
+				this.$initMethodsAndListeners( methodNames, listenerNames )
+
+			} else {
+
+				// ========= RESPONSE =========
+
+				const { type, index, name, res } = message
+				this.$handleResponse( type, index, name, res )
+			}
+
+			if (this.finishConstruct) {
+				HUH('INITED / finishConstruct')
+				this.finishConstruct()
+				this.finishConstruct = null
+			}
+		})
+
+		// ========= ERROR =========
+
+		this.$worker.on('error', message => {
+			ERR('ERROR:', message)
+			this.$call( 'error', message )
+		})
+
+		// ========= EXIT =========
+
+		this.$worker.on('exit', message => {
+			HMM('EXIT:', message)
+			this.$call( 'exit', message )
+		})
+
+		// ========= ONLINE =========
+
+		this.$worker.on('online', message => {
+			YAY('WORKER ONLINE')
+			this.$call( 'online', true )
+		})
+
+		// ========= INIT =========
+
+		return new Promise( resolve => {
+			HMM('INITIIALISE (wait)')
+			this.finishConstruct = resolve
+		})
+	}
+
+
+}

package/lib/workers/index.js

@@ -0,0 +1,9 @@
+//////////////////////////////////////////
+//                                      //
+//                                      //
+//             AUTOWORKER               //
+//                                      //
+//                                      //
+//////////////////////////////////////////
+
+export * from './_AutoWorker.js'

package/package.json

@@ -1,32 +1,32 @@
 {
   "name": "agnostics",
-  "version": "0.0.2",
+  "version": "0.0.4",
   "author": "Autr <g@sinnott.cc>",
   "description": "featherless birds",
+  "esversion": 6,
+  "type": "module",
   "exports": {
     ".": {
-      "types": "./types/lib/index.d.ts",
+      "types": "./types/index.d.ts",
       "default": "./lib/index.js"
     },
     "./inputs": {
-      "types": "./types/lib/inputs/index.d.ts",
+      "types": "./types/inputs/index.d.ts",
       "default": "./lib/inputs/index.js"
     },
     "./helpers": {
-      "types": "./types/lib/helpers/index.d.ts",
+      "types": "./types/helpers/index.d.ts",
       "default": "./lib/helpers/index.js"
     },
     "./specification": {
-      "types": "./types/lib/specification/index.d.ts",
+      "types": "./types/specification/index.d.ts",
       "default": "./lib/specification/index.js"
     },
     "./logger": {
-      "types": "./types/lib/logger/index.d.ts",
+      "types": "./types/logger/index.d.ts",
       "default": "./lib/logger/index.js"
     }
   },
   "files": [ "lib", "types" ],
-  "esversion": 6,
-  "type": "module",
   "dependencies": {}
 }