boot-server.tsx

@@ -0,0 +1,15 @@
+import "./run-serve.tsx";
+
+Deno.args.forEach(arg=>
+{
+    if(arg.startsWith("--"))
+    {
+        const kvp = arg.substring(2).split("=");
+        Deno.env.set(kvp[0], kvp[1] || "true");
+    }
+});
+
+if(Deno.env.get("dev"))
+{
+  await import("./run-local.tsx");
+}

deno.json

@@ -11,7 +11,7 @@
     },
     "tasks":
     {
-        "local": "deno run -A --no-lock ./run-local.tsx --port=1234",
+        "local": "deno run -A --no-lock ./local.tsx",
-        "serve": "deno run -A --no-lock ./run-serve.tsx --port=1234"
+        "serve": "deno run -A --no-lock ./serve.tsx"
     }
 }

example/app.tsx

@@ -1,3 +1,4 @@
+import "@able/boot-server.tsx";
 import React from "react";
 
 const CTXString = React.createContext("lol");
@@ -36,8 +37,8 @@ export default ()=>
     const [Store, Dispatch] = React.useReducer(reducer, {name:"seth", age:24} as Store, builder)
     return <CTXString.Provider value="intradestink">
         <div class="my-4 font-sans">
-            <h1 class="font-black text-xl text-red-500">Title</h1>
+            <h1 class="font-black text-xl text-red-500">Title????</h1>
-            <h2 class="font-black text-blue-500">subtitle</h2>
+            <h2>subtitle!</h2>
             <p>
                 <button onClick={e=>Dispatch(1)}>{Store.name}|{Store.age}?</button>
             </p>

example/deno.json

@@ -3,11 +3,11 @@
     "imports":
     {
         "react":"https://esm.sh/preact@10.15.1/compat",
-        "entry":"./app.tsx"
+        "@able/":"http://localhost:4507/"
     },
     "tasks":
     {
-        "local": "deno run -A --no-lock --reload=http://localhost:1234 http://localhost:1234/run-local.tsx",
+        "local": "deno run -A --no-lock --reload=http://localhost:4507 app.tsx --dev",
-        "serve": "deno run -A --no-lock --reload=http://localhost:1234 http://localhost:1234/run-serve.tsx"
+        "serve": "deno run -A --no-lock --reload=http://localhost:4507 app.tsx"
     }
 }

example/dyn-test.tsx

@@ -1,15 +0,0 @@
-
-import * as Util from "@able/";
-import * as React from "react";
-import {createElement} from "react/client";
-
-import('react').then((module) => {
-  console.log(module);
-});
-
-
-function unimport(n:number)
-{
-  return n;
-}
-unimport(123)

hmr-listen.tsx

@@ -13,7 +13,7 @@ Socket.addEventListener('message', async(event:{data:string})=>
 {
     // When a file changes, dynamically re-import it to get the updated members
     // send the updated members to any listeners for that file
-    const reImport = await import(document.location.origin+event.data+"?reload="+Math.random());
+    const reImport = await import(event.data+"?reload="+Math.random());
     FileListeners.get(event.data)?.forEach(reExport=>reExport(reImport));
     HMR.update();
 });

hmr-static.tsx

@@ -1,140 +0,0 @@
-
-type GlyphCheck = (inGlyph:string)=>boolean
-const isAlphaLike:GlyphCheck =(inGlyph:string)=>
-{
-    const inCode = inGlyph.charCodeAt(0);
-
-    if(inCode >= 97 && inCode <= 122)
-    {
-        return true;
-    }
-
-    if(inCode >= 65 && inCode <= 90)
-    {
-        return true;
-    }
-
-    return `$_.`.includes(inGlyph);
-}
-const isWhiteSpace:GlyphCheck =(inGlyph:string)=> `\n\r\t `.includes(inGlyph);
-const isQuote:GlyphCheck =(inGlyph:string)=>`"'\``.includes(inGlyph)
-const isNot =(inCheck:GlyphCheck)=> (inGlyph:string)=>!inCheck(inGlyph);
-const contiguous =(inText:string, inStart:number, inTest:GlyphCheck):number=>
-{
-    let ok = true;
-    let index = inStart;
-    let count = 0;
-    while(ok && count < inText.length)
-    {
-        count++;
-        ok = inTest(inText.charAt(index++));
-    }
-    return index-1;
-}
-
-const findNextExport =(inFile:string, inIndex=0, inLocal:Array<string>, inForeign:Array<string>)=>
-{
-    const pos = inFile.indexOf("export", inIndex);
-    if(pos !== -1)
-    {
-        if(!isAlphaLike(inFile.charAt(pos-1)) || !isAlphaLike(inFile.charAt(pos+6)))
-        {
-            
-            const nextCharInd = contiguous(inFile, pos+6, isWhiteSpace);
-            const nextChar = inFile[nextCharInd];
-
-            //console.log(inFile.substring(pos, nextCharInd+1), `>>${nextChar}<<`)
-
-            if(nextChar === "*")
-            {
-                const  firstQuoteInd = contiguous(inFile,   nextCharInd+1, isNot(isQuote) );
-                const secondQuoteInd = contiguous(inFile, firstQuoteInd+1, isNot(isQuote) );
-                //console.log("ASTERISK:", inFile.substring(pos, secondQuoteInd+1));
-                inForeign.push(inFile.substring(nextCharInd, secondQuoteInd+1));
-            }
-            else if(nextChar == "{")
-            {
-                const endBracketInd = contiguous(inFile, nextCharInd, (inGlyph:string)=>inGlyph!=="}");
-                const nextLetterInd = contiguous(inFile, endBracketInd+1, isWhiteSpace);
-                if(inFile.substring(nextLetterInd, nextLetterInd+4) == "from")
-                {
-                    const  firstQuoteInd = contiguous(inFile, nextLetterInd+4, isNot(isQuote) );
-                    const secondQuoteInd = contiguous(inFile, firstQuoteInd+1, isNot(isQuote) );
-                    //console.log(`BRACKET foreign: >>${inFile.substring(nextCharInd, secondQuoteInd+1)}<<`);
-                    inForeign.push(inFile.substring(nextCharInd, secondQuoteInd+1));
-                }
-                else
-                {
-                    const members = inFile.substring(nextCharInd+1, endBracketInd);
-                    members.split(",").forEach(part=>
-                    {
-                        const renamed = part.split(" as ");
-                        inLocal.push(renamed[1] || renamed[0]);
-                    });
-                }
-                
-            }
-            else if(isAlphaLike(nextChar))
-            {
-                const keywordEndInd = contiguous(inFile, nextCharInd, isAlphaLike);
-                const keyword = inFile.substring(nextCharInd, keywordEndInd);
-                if(keyword === "default")
-                {
-                    inLocal.push(keyword);
-                    //console.log(`MEMBER: >>${keyword})}<<`);
-                }
-                else if(["const", "let", "var", "function", "class"].includes(keyword))
-                {
-                    const varStartInd = contiguous(inFile, keywordEndInd+1, isWhiteSpace);
-                    const varEndInd = contiguous(inFile, varStartInd+1, isAlphaLike);
-                    //console.log(`MEMBER: >>${inFile.substring(varStartInd, varEndInd)}<<`);
-                    inLocal.push(inFile.substring(varStartInd, varEndInd))
-                }
-            }
-        }
-
-        return pos + 7;
-    }
-    else
-    {
-        return false;
-    }
-};
-
-export const Exports =(inFile:string)=>
-{
-    let match = 0 as number|false;
-    let count = 0;
-    const local = [] as string[];
-    const foreign = [] as string[];
-    while(match !== false && count <200)
-    {
-        count++;
-        match = findNextExport(inFile, match, local, foreign);
-    }
-    return[local, foreign] as [local:string[], foreign:string[]];
-};
-
-export const FileExports =async(inURL:string|URL)=>
-{
-    console.log("scanning", inURL, "for exports")
-    const resp = await fetch(inURL);
-    const text = await resp.text();
-    return Exports(text);
-}
-
-//console.log(await FileExports(import.meta.resolve("./hmr-listen.tsx")));
-
-/*
-const [local, global] = Exports(`
-// export in comment
-export * from "react";
-const fakeexport =()=>{};
-export{ thing1 as remapped, thing2}
-export{ thing1 as remapped, thing2} from 'React';
-export 
-export const func=()=>{};
-`);
-
-console.log(local, global);
-*/

iso-elements.tsx

@@ -1,396 +0,0 @@
-import React from "react";
-
-type MetasInputs = { [Property in MetaKeys]?: string };
-type MetasModeArgs = {concatListed?:string; dropUnlisted?:boolean};
-type MetasStackItem = MetasModeArgs&MetasInputs&{id:string, depth:number}
-type Meta = {title:string, description:string, keywords:string, image:string, canonical:string }
-type MetaKeys = keyof Meta;
-
-export const Meta =
-{
-    Stack:[] as MetasStackItem[],
-    Meta: {
-        title:"",
-        description:"",
-        keywords:"",
-        image:"",
-        canonical:""
-    } as Meta,
-    ComputeFinal(inStack:MetasStackItem[], inStart=0)
-    {
-        const seed = {
-            title:"",
-            description:"",
-            keywords:"",
-            image:"",
-            canonical:""
-        };
-        if(inStack.length>0)
-        {
-            let final = {...seed, ...inStack[0]};
-            for(let i=inStart+1; i<inStack.length; i++)
-            {
-                const curr = inStack[i];
-                Object.keys(seed).forEach(key=>
-                {
-                    const lookup = key as MetaKeys
-                    const valPrev = final[lookup];
-                    const valCurr = curr[lookup];
-
-                    if(valPrev && !valCurr)
-                    {
-                        final[lookup] = curr.dropUnlisted ? "" : valPrev;
-                    }
-                    else if(valPrev && valCurr)
-                    {
-                        final[lookup] = curr.concatListed ? valPrev + curr.concatListed + valCurr : valCurr
-                    }
-                    else
-                    {
-                        final[lookup] = valCurr||"";
-                    }
-                });
-            }
-            return final;
-        }
-        else
-        {
-            return seed;
-        }
-    },
-    Context: React.createContext([[], ()=>{}] as [Get:MetasStackItem[], Set:React.StateUpdater<MetasStackItem[]>]),
-    Provider({children}:{children:Children})
-    {
-        const binding = React.useState([] as MetasStackItem[]);
-
-        type MetaDOM = {description:NodeListOf<Element>, title:NodeListOf<Element>, image:NodeListOf<Element>, url:NodeListOf<Element>};
-
-        const refElements = React.useRef(null as null | MetaDOM);
-
-        React.useEffect(()=>
-        {
-            refElements.current = {
-                description:document.querySelectorAll(`head > meta[name$='description']`),
-                title:document.querySelectorAll(`head > meta[name$='title']`),
-                image:document.querySelectorAll(`head > meta[name$='image']`),
-                url:document.querySelectorAll(`head > link[rel='canonical']`)
-            };
-        }, []);
-
-        React.useEffect(()=>
-        {
-            if(refElements.current)
-            {
-                const final = Meta.ComputeFinal(binding[0]);
-
-                refElements.current.url.forEach(e=>e.setAttribute("content", final.canonical||""));
-                document.title = final.title;
-                refElements.current.title.forEach(e=>e.setAttribute("content", final.title||""));
-                refElements.current.image.forEach(e=>e.setAttribute("content", final.image||""));
-                refElements.current.description.forEach(e=>e.setAttribute("content", final.description||""));
-            }
-        });
-        return <Meta.Context.Provider value={binding}>{children}</Meta.Context.Provider>;
-    },
-    Metas({concatListed=undefined, dropUnlisted=false, ...props}:MetasModeArgs&MetasInputs):null
-    {
-        const id = React.useId();
-        const [, metasSet] = React.useContext(Meta.Context);
-        const {depth} = React.useContext(SwitchContext);
-
-        React.useEffect(()=>{
-            metasSet((m)=>{
-                console.log(`adding meta`, props, depth);
-                const clone = [...m];
-                let i;
-                for(i=clone.length-1; i>-1; i--)
-                {
-                    if(clone[i].depth <= depth)
-                    {
-                        break;
-                    }
-                }
-                clone.splice(i+1, 0, {id, depth, concatListed, dropUnlisted, ...props});
-                return clone;
-            });
-            return ()=>
-            {
-                metasSet((m)=>{
-                    const clone = [...m];
-                    const ind = clone.findIndex(i=>i.id === id);      
-                    if(ind > -1)
-                    {
-                        console.log(`removing meta`, props, depth);
-                        clone.splice(ind, 1);
-                    } 
-                    return clone;
-                });
-
-            };
-        }, []);
-
-        React.useEffect(()=>{
-            metasSet((m)=>{
-                const clone = [...m];
-                const ind = clone.findIndex(i=>i.id === id);      
-                if(ind > -1)
-                {
-                    console.log(`updating meta`, props, depth);
-                    clone[ind] = {...clone[ind], ...props};
-                } 
-                return clone;
-            });
-        }, Object.keys(props).map( (key) => props[key as MetaKeys] ));
-
-        if(!window.innerWidth && props.title)
-        {
-            Meta.Stack.push({id, depth, concatListed, dropUnlisted, ...props});
-        }
-
-        return null;
-    }
-};
-
-
-export type Children = string | number | React.JSX.Element | React.JSX.Element[];
-
-type RoutePath = Array<string>;
-type RouteParams = Record<string, string|number|boolean>;
-type RouteState = {URL:URL, Path:RoutePath, Params:RouteParams, Anchor:string};
-type RouteContext = [Route:RouteState, Update:(inPath?:RoutePath, inParams?:RouteParams, inAnchor?:string)=>void];
-type RouteProps = {children:Children, url?:URL };
-export const Router = {
-    Parse(url:URL):RouteState
-    {
-        const Path = url.pathname.substring(1, url.pathname.endsWith("/") ? url.pathname.length-1 : url.pathname.length).split("/");
-        const Params:RouteParams = {};
-        new URLSearchParams(url.search).forEach((k, v)=> Params[k] = v);
-        const Anchor = url.hash.substring(1);
-        return {URL:url, Path, Params, Anchor} as RouteState;
-    },
-    Context:React.createContext([{URL:new URL("https://original.route/"), Path:[], Params:{}, Anchor:""}, ()=>{}] as RouteContext),
-    Provider(props:RouteProps)
-    {
-        const [routeGet, routeSet] = React.useState(Router.Parse(props.url || new URL(document.location.href)));
-        const [dirtyGet, dirtySet] = React.useState(true);
-
-        const routeUpdate:RouteContext[1] =(inPath, inParams, inAnchor)=>
-        {
-            const clone = new URL(routeGet.URL);
-            inPath && (clone.pathname = inPath.join("/"));
-            inParams && (clone.search = new URLSearchParams(inParams as Record<string, string>).toString());
-            routeSet({
-                URL:clone,
-                Path: inPath || routeGet.Path,
-                Params: inParams || routeGet.Params,
-                Anchor: inAnchor || routeGet.Anchor
-            });
-        };
-
-        // when the state changes, update the page url
-        React.useEffect(()=> dirtyGet ? dirtySet(false) : history.pushState({...routeGet, URL:undefined}, "", routeGet.URL), [routeGet.URL.href]);
-
-        React.useEffect(()=>{
-            history.replaceState({...routeGet, URL:undefined}, "", routeGet.URL);
-            window.addEventListener("popstate", ({state})=>
-            {
-                dirtySet(true);
-                routeUpdate(state.Path, state.Params, state.Anchor);
-            });
-            document.addEventListener("click", e=>
-            {
-                const path = e.composedPath() as HTMLAnchorElement[];
-                for(let i=0; i<path.length; i++)
-                {
-                    if(path[i].href)
-                    {
-                        const u = new URL(path[i].href);
-                        if(u.origin == document.location.origin)
-                        {
-                            e.preventDefault();
-                            const parts = Router.Parse(u);
-                            routeUpdate(parts.Path, parts.Params, parts.Anchor);
-                        }
-                        return;
-                    }
-                }
-            })
-        }, []);
-
-        return <Router.Context.Provider value={[routeGet, routeUpdate]}>{props.children}</Router.Context.Provider>;
-    },
-    Consumer()
-    {
-        return React.useContext(Router.Context);
-    }
-};
-
-type SwitchContext = {depth:number, keys:Record<string, string>};
-export const SwitchContext = React.createContext({depth:0, keys:{}} as SwitchContext);
-export const Switch =({children}:{children:Children})=>
-{
-    let fallback = null;
-    if(Array.isArray(children))
-    {
-        const contextSelection = React.useContext(SwitchContext);
-        const [contextRoute] = Router.Consumer();
-        const routeSegment = contextRoute.Path.slice(contextSelection.depth);
-        const checkChild =(inChild:{props:{value?:string}})=>
-        {
-            if(inChild?.props?.value)
-            {   
-                const parts = inChild.props.value.split("/");
-                if(parts.length > routeSegment.length)
-                {
-                    return false;
-                }
-    
-                const output:SwitchContext = {depth:contextSelection.depth+parts.length, keys:{}};
-                for(let i=0; i<parts.length; i++)
-                {
-                    const partRoute = routeSegment[i];
-                    const partCase = parts[i];
-                    if(partCase[0] == ":")
-                    {
-                        output.keys[partCase.substring(1)] = partRoute;
-                    }
-                    else if(partCase != "*" && partCase != partRoute)
-                    {
-                        return false;
-                    }
-                }
-                return output;
-            }
-            return false;
-        }
-
-        for(let i=0; i<children.length; i++)
-        {
-            const childCase =  children[i];
-            const childCaseChildren = childCase.props?.__args?.slice(2) || childCase.props.children;
-            const newContextValue = checkChild(childCase);
-            if(newContextValue)
-            {
-                return <SwitchContext.Provider value={newContextValue}>{childCaseChildren}</SwitchContext.Provider>
-            }
-            if(childCase?.props?.default && !fallback)
-            {
-                //console.log(routeSegment);
-                fallback = childCaseChildren;
-            }
-        } 
-    }
-
-    return fallback;
-};
-export const Case =({children, value}:{children:Children, value?:string, default?:true})=>null;
-export const useRouteVars =()=> React.useContext(SwitchContext).keys;
-
-export type FetchCachOptions = {CacheFor:number, CacheOnServer:boolean, DelaySSR:boolean, Seed:boolean};
-export type FetchRecord = {URL:string, Promise?:Promise<FetchRecord>, CachedAt:number, Error?:string, JSON?:object} & FetchCachOptions;
-type FetchGuide = [Record:FetchRecord, Init:boolean, Listen:boolean];
-export type FetchHookState = [Data:undefined|object, Updating:boolean];
-export const Fetch = {
-    Cache:new Map() as Map<string, FetchRecord>,
-    ServerBlocking:false as false|Promise<FetchRecord>[],
-    ServerTouched:false as false|Set<FetchRecord>,
-    ServerRemove:false as false|Set<FetchRecord>,
-    Seed(seed:FetchRecord[])
-    {
-        seed.forEach(r=>{
-            //r.Promise = Promise.resolve(r);
-            Fetch.Cache.set(r.URL, r)
-        });
-    },
-    DefaultOptions:{CacheFor:60, CacheOnServer:true, DelaySSR:true, Seed:true} as FetchCachOptions,
-    Request(URL:string, Init?:RequestInit|null, CacheFor:number = 60, CacheOnServer:boolean = true, DelaySSR:boolean = true, Seed:boolean = true):FetchGuide
-    {
-        let check = Fetch.Cache.get(URL);
-        
-        const load =(inCheck:FetchRecord)=>
-        {
-            Fetch.Cache.set(URL, inCheck);
-            inCheck.CachedAt = 0;
-            inCheck.Promise = fetch(URL, Init?Init:undefined).then(resp=>resp.json()).then((json)=>{
-                inCheck.JSON = json;
-                inCheck.CachedAt = new Date().getTime();
-                //console.log(`...cached!`);
-                return inCheck;
-            });
-            return inCheck;
-        };
-
-        if(!check)
-        {
-            // not in the cache
-            // - listen
-
-            //console.log(`making new cache record...`);
-            return [load({URL, CacheFor, CachedAt:0, CacheOnServer, DelaySSR, Seed}), false, true];
-        }
-        else if(check.CachedAt == 0)
-        {
-            // loading started but not finished
-            // - listen
-            // - possibly init if there is something in JSON
-
-            //console.log(`currently being cached...`);
-            return [check, check.JSON ? true : false, true];
-        }
-        else
-        {
-            //console.log(`found in cache...`);
-            let secondsAge = (new Date().getTime() - check.CachedAt)/1000;
-            if(secondsAge > check.CacheFor)
-            {
-                // cached but expired
-                // - listen
-                // - init
-                //console.log(`...outdated...`);
-                return [load(check), true, true];
-            }
-            else
-            {
-                // cached and ready
-                // - init
-                //console.log(`...retrieved!`);
-                return [check, true, false];
-            }
-
-        }
-    },
-
-    Use(URL:string, Init?:RequestInit|null, Options?:FetchCachOptions)
-    {
-        const config = {...Fetch.DefaultOptions, ...Options};
-        const [receipt, init, listen] = Fetch.Request(URL, Init, config.CacheFor, config.CacheOnServer, config.DelaySSR, config.Seed);
-        const initialState:FetchHookState = init ? [receipt.JSON, listen] : [undefined, true];
-        const [cacheGet, cacheSet] = React.useState(initialState);
-
-        if(Fetch.ServerBlocking && Fetch.ServerTouched && config.DelaySSR) // if server-side rendering
-        {
-            if(listen) // if the request is pending
-            {
-                receipt.Promise && Fetch.ServerBlocking.push(receipt.Promise); // add promise to blocking list
-                return [undefined, listen] as FetchHookState; // no need to return any actual data while waiting server-side
-            }
-            else // if request is ready
-            {
-                receipt.Seed && Fetch.ServerTouched.add(receipt); // add record to client seed list (if specified in receipt.seed)
-                return [receipt.JSON, false] as FetchHookState;
-            }
-        }
-
-        React.useEffect(()=>
-        {
-            if(listen)
-            {
-                //const receipt = Fetch.Request(URL, Init, CacheFor, CacheOnServer, DelaySSR);
-                receipt.Promise?.then(()=>cacheSet([receipt.JSON, receipt.CachedAt === 0]));
-            }
-        }
-        , []);
-
-        return cacheGet;
-    }
-};

iso-menu.tsx

@@ -1,224 +0,0 @@
-import React from "react";
-
-type StateArgs = {done?:boolean, open?:boolean};
-type StateObj = {done:boolean, open:boolean};
-type StateBinding = [state:StateObj, update:(args:StateArgs)=>void];
-
-const CTX = React.createContext([{done:true, open:false}, (args)=>{}] as StateBinding);
-
-export const Group =(props:{children:React.JSX.Element|React.JSX.Element[]})=>
-{
-    const [stateGet, stateSet] = React.useState({done:true, open:false} as StateObj);
-    return <CTX.Provider value={[stateGet, (args:StateArgs)=> stateSet({...stateGet, ...args})]}>{props.children}</CTX.Provider>;
-};
-
-export const Menu =(props:{children:React.JSX.Element|React.JSX.Element[]})=>
-{
-    const [stateGet, stateSet] = React.useContext(CTX);
-    const refElement:React.MutableRefObject<HTMLElement|null> = React.useRef( null );
-    const refControl:React.MutableRefObject<CollapseControls|null> = React.useRef( null );
-    const refInitial:React.MutableRefObject<boolean> = React.useRef(true);
-
-    type MenuClassStates = {Keep:string, Open:string, Shut:string, Move:string, Exit:string};
-    const base = `relative transition-all border(8 black) overflow-hidden`;
-    const Classes:MenuClassStates =
-    {
-      Shut: `${base} h-0    top-0  w-1/2   duration-300`,
-      Open: `${base} h-auto top-8  w-full  duration-700`,
-      lol: `${base} h-auto top-36 bg-yellow-500  w-2/3  duration-700`,
-    };
-    const Window = window as {TwindInst?:(c:string)=>string};
-    if(Window.TwindInst)
-    {
-      for(let stateName in Classes)
-      {
-        Classes[stateName as keyof MenuClassStates] = Window.TwindInst(Classes[stateName as keyof MenuClassStates]);
-      }
-    }
-
-    React.useEffect(()=>
-    {
-      refControl.current = refElement.current && Collapser(refElement.current, stateGet.open ? "Open" : "Shut", Classes);
-    }
-    , []);
-    React.useEffect(()=>
-    {
-      (!refInitial.current && refControl.current) && refControl.current(stateGet.open ? "Open" : "Shut", ()=>stateSet({done:true}));
-      refInitial.current = false;
-    }
-    , [stateGet.open]);
-
-    useAway(refElement, (e)=>stateSet({open:false, done:false}) );
-
-    return <div ref={refElement as React.Ref<HTMLDivElement>} class={Classes.Shut}>
-      { (!stateGet.open && stateGet.done) ? null : props.children}
-    </div>;
-};
-
-export const Button =()=>
-{
-    const [stateGet, stateSet] = React.useContext(CTX);
-    return <>
-        <p>{JSON.stringify(stateGet)}</p>
-        <button class="px-10 py-2 bg-red-500 text-white" onClick={e=>stateSet({open:true,  done:false})}>Open</button>
-        <button class="px-10 py-2 bg-red-500 text-white" onClick={e=>stateSet({open:false, done:false})}>Close</button>
-    </>;
-};
-
-type Handler = (e:MouseEvent)=>void
-const Refs:Map<HTMLElement, React.Ref<Handler>> = new Map();
-function isHighest(inElement:HTMLElement, inSelection:HTMLElement[])
-{
-  let currentNode = inElement;
-  while (currentNode != document.body)
-  {
-    currentNode = currentNode.parentNode as HTMLElement;
-    if(currentNode.hasAttribute("data-use-away") && inSelection.includes(currentNode))
-    {
-      return false;
-    }    
-  }
-  return true;
-}
-window.innerWidth && document.addEventListener("click", e=>
-{
-  const path = e.composedPath();
-  const away:HTMLElement[] = [];
-
-  Refs.forEach( (handlerRef, element)=>
-  {
-    if(!path.includes(element) && handlerRef.current)
-    {
-      away.push(element);
-    }
-  });
-
-  away.forEach((element)=>
-  {
-    if(isHighest(element, away))
-    {
-      const handler = Refs.get(element);
-      handler?.current && handler.current(e);
-    }
-  });
-
-}
-, true);
-const useAway =(inRef:React.Ref<HTMLElement>, handleAway:Handler)=>
-{
-  const refHandler:React.MutableRefObject<Handler> = React.useRef(handleAway);
-  refHandler.current = handleAway;
-
-  React.useEffect(()=>
-  {
-    if(inRef.current)
-    {
-      inRef.current.setAttribute("data-use-away", "0");
-      Refs.set(inRef.current, refHandler);      
-    }
-    return ()=> inRef.current && Refs.delete(inRef.current);
-  }
-  , []);
-};
-
-type StyleSize = [classes:string, width:number, height:number];
-type StylePack = Record<string, string>;
-type StyleCalc = Record<string, StyleSize>;
-const StyleCalc =(inElement:HTMLElement, inClasses:StylePack)=>
-{
-  const initialStyle = inElement.getAttribute("style")||"";
-  const initialClass = inElement.getAttribute("class")||"";
-  const output = {} as StyleCalc;
-
-  inElement.setAttribute("style", `transition: none;`);
-  Object.entries(inClasses).forEach(([key, value])=>
-  {
-    inElement.setAttribute("class", value);
-    output[key] =  [value, inElement.offsetWidth, inElement.offsetHeight];
-  });
-  inElement.setAttribute("class", initialClass);
-  inElement.offsetHeight; // this has be be exactly here
-  inElement.setAttribute("style", initialStyle);
-
-  return output;
-};
-
-type DoneCallback =(inState:string)=>void;
-export type CollapseControls =(inOpen?:string, inDone?:DoneCallback)=>void;
-export function Collapser(inElement:HTMLElement, initialState:string, library:Record<string, string>)
-{
-    let userDone:DoneCallback = (openState) => {};
-    let userMode = initialState;
-    let frameRequest = 0;
-    let inTransition = false;
-    let measurements:StyleCalc;
-    const transitions:Set<string> = new Set();
-
-    const run = (inEvent:TransitionEvent)=> (inEvent.target == inElement) && transitions.add(inEvent.propertyName);
-    const end = (inEvent:TransitionEvent)=>
-    {
-      if (inEvent.target == inElement)
-      {
-        transitions.delete(inEvent.propertyName);
-        if(transitions.size === 0)
-        {
-          measurements = StyleCalc(inElement, library);
-          const [, w, h] = measurements[userMode];
-          if(inElement.offsetHeight != h || inElement.offsetWidth != w)
-          {
-            anim(userMode, userDone);
-          }
-          else
-          {
-            inElement.setAttribute("style", "");
-            inTransition = false;
-            userDone(userMode);   
-          }
-        }
-      }
-    };
-    const anim = function(inState:string, inDone)
-    {
-      cancelAnimationFrame(frameRequest);
-
-      if(arguments.length)
-      {
-        if(!library[inState]){ return; }
-
-        userDone = inDone|| ((m)=>{}) as DoneCallback;
-        userMode = inState;
-
-        if(!inTransition)
-        {
-          measurements = StyleCalc(inElement, library);
-        }
-
-        if(measurements)
-        {
-          const [classes, width, height] = measurements[inState] as StyleSize;
-          const oldWidth = inElement.offsetWidth;
-          const oldHeight = inElement.offsetHeight;
-          inElement.style.width  = oldWidth  + "px";
-          inElement.style.height = oldHeight + "px";
-          inTransition = true;
-
-          frameRequest = requestAnimationFrame(()=>
-          {
-            inElement.style.height = height + "px";
-            inElement.style.width = width + "px";
-            inElement.className = classes;
-          });
-        }
-      }
-      else
-      {
-        inElement.removeEventListener("transitionrun", run);
-        inElement.removeEventListener("transitionend", end);
-      }
-    } as CollapseControls;
-
-    inElement.addEventListener("transitionend", end);
-    inElement.addEventListener("transitionrun", run);
-
-    return anim;
-} 

run-deploy.tsx

@@ -1,98 +0,0 @@
-import { load } from "https://deno.land/std@0.194.0/dotenv/mod.ts";
-import { parse } from "https://deno.land/std@0.194.0/flags/mod.ts";
-
-
-const collect =async(inKey:string, inArg:Record<string, string>, inEnv:Record<string, string>):Promise<string|undefined>=>
-{
-    const scanArg = inArg[inKey];
-    const scanEnvFile = inEnv[inKey];
-    const scanEnvDeno = Deno.env.get(inKey);
-
-    if(scanArg)
-    {
-        console.log(`Using "${inKey}" from passed argument.`);
-        return scanArg;
-    }
-    if(scanEnvFile)
-    {
-        console.log(`Using "${inKey}" from .env file.`);
-        return scanEnvFile;
-    }
-    if(scanEnvDeno)
-    {
-        console.log(`Using "${inKey}" from environment variable.`);
-        return scanEnvDeno;
-    }
-
-    const scanUser = await prompt(`No "${inKey}" found. Enter one here:`);
-    if(!scanUser || scanUser?.length < 3)
-    {
-        console.log("Exiting...");
-        Deno.exit();
-    }
-};
-
-const prompt =async(question: string):Promise<string>=>
-{
-    const buf = new Uint8Array(1024);
-    await Deno.stdout.write(new TextEncoder().encode(question));
-    const bytes = await Deno.stdin.read(buf);
-    if (bytes) {
-        return new TextDecoder().decode(buf.subarray(0, bytes)).trim();
-    }
-    throw new Error("Unexpected end of input");
-};
-
-try
-{
-    console.log("Runing deploy!");
-    const serveScript = import.meta.resolve("./run-serve.tsx");
-    console.log("Serve script:", serveScript);
-
-    let arg = parse(Deno.args);
-    let env = await load();
-
-    let useToken = await collect("DENO_DEPLOY_TOKEN", arg, env);
-    let useProject = await collect("DENO_DEPLOY_PROJECT", arg, env);
-    let useEntry = await collect("DENO_DEPLOY_ENTRY", arg, env);
-
-    Deno.env.set("DENO_DEPLOY_TOKEN", useToken || "");
-    Deno.env.set("DENO_DEPLOY_ENTRY", useEntry || "");
-
-
-    const command = new Deno.Command(
-        `deno`,
-        {
-            args:[
-                "run",
-                "-A",
-                "--no-lock",
-                "https://deno.land/x/deploy/deployctl.ts",
-                "deploy",
-                `--project=${useProject}`,
-                serveScript
-            ],
-            stdin: "piped",
-            stdout: "piped"
-        }
-    );
-
-    const child = command.spawn();
-    
-    // open a file and pipe the subprocess output to it.
-    const writableStream = new WritableStream({
-        write(chunk: Uint8Array): Promise<void> {
-            Deno.stdout.write(chunk);
-            return Promise.resolve();
-        },
-    });
-    child.stdout.pipeTo(writableStream);
-
-    // manually close stdin
-    child.stdin.close();
-    const status = await child.status;
-}
-catch(e)
-{
-    console.error(e);
-}

run-local.tsx

@@ -1,5 +1,4 @@
 import {Configure, Transpile, Extension} from "./run-serve.tsx";
-import * as Collect from "./hmr-static.tsx";
 
 const SocketsLive:Set<WebSocket> = new Set();
 const SocketsSend =(inData:string)=>{ for (const socket of SocketsLive){ socket.send(inData); } }
@@ -22,40 +21,25 @@ Configure({
     Remap: (inImports, inConfig)=>
     {
         inImports["react-original"] = inImports["react"];
-        inImports["react"] = import.meta.resolve(`./hmr-react.tsx`);
+        inImports["react"] = `${inConfig.Spoof}/hmr-react.tsx`;
         return inImports;
     },
     async Serve(inReq, inURL, inExt, inMap, inConfig)
     {
-        if(Transpile.Check(inExt) && !inURL.searchParams.get("reload"))
+        if(Transpile.Check(inExt) && !inURL.searchParams.get("reload") && !inURL.pathname.startsWith(inConfig.Spoof+"/"))
         {
+            const imp = await import(inConfig.Proxy+inURL.pathname);
+            const members = [];
+            for( const key in imp ) { members.push(key); }
 
-//            const imp = await import(inConfig.Proxy+inURL.pathname);
-//            const members = [];
-//            for( const key in imp ) { members.push(key); }
-//
-//            const code =`
-//import {FileListen} from "${import.meta.resolve(`./hmr-listen.tsx`)}";
-//import * as Import from "${inURL.pathname}?reload=0";
-//${ members.map(m=>`let proxy_${m} = Import.${m}; export { proxy_${m} as ${m} };`).join("\n") }
-//FileListen("${inURL.pathname}", (updatedModule)=>
-//{
-//    ${ members.map(m=>`proxy_${m} = updatedModule.${m};`).join("\n") }
-//});`            
-
-            // we dont need to add ?reload= because this fetch is by way the file system not the hosted url
-            const [local, foreign] = await Collect.FileExports(inConfig.Proxy+inURL.pathname);
-            console.log(local, foreign);
             const code =`
-import {FileListen} from "${import.meta.resolve(`./hmr-listen.tsx`)}";
+import {FileListen} from "${inConfig.Spoof}/hmr-listen.tsx";
 import * as Import from "${inURL.pathname}?reload=0";
-${ local.map(m=>`let proxy_${m} = Import.${m}; export { proxy_${m} as ${m} };`).join("\n") }
+${ members.map(m=>`let proxy_${m} = Import.${m}; export { proxy_${m} as ${m} };`).join("\n") }
 FileListen("${inURL.pathname}", (updatedModule)=>
 {
-    ${ local.map(m=>`proxy_${m} = updatedModule.${m};`).join("\n") }
+    ${ members.map(m=>`proxy_${m} = updatedModule.${m};`).join("\n") }
-});
+});`            
-${ foreign.join(";\n") }
-`    
 
             return new Response(code, {headers:{"content-type":"application/javascript"}});
         }

run-serve.tsx

@@ -1,28 +1,9 @@
 import * as MIME from "https://deno.land/std@0.180.0/media_types/mod.ts";
+import * as HTTP from "https://deno.land/std@0.177.0/http/server.ts";
 import * as SWCW from "https://esm.sh/@swc/wasm-web@1.3.62";
 
-
-Deno.args.forEach(arg=>
-{
-    if(arg.startsWith("--"))
-    {
-        const kvp = arg.substring(2).split("=");
-        Deno.env.set(kvp[0], kvp[1] || "true");
-    }
-});
-
-const urls = {
-    Cwd: new URL(`file://${Deno.cwd().replaceAll("\\", "/")}`).toString(),
-    App: Deno.mainModule,
-    Mod: import.meta.url,
-    Look: import.meta.resolve("./boot.tsx")
-};
-
-console.log(JSON.stringify(urls, null, " "));
-
 type DenoConfig = {imports:Record<string, string>};
 const ImportMap:DenoConfig = {imports:{}};
-let ImportMapOriginal = {};
 const ImportMapReload =async()=>
 {
     let json:DenoConfig;
@@ -33,7 +14,6 @@ const ImportMapReload =async()=>
         json = await resp.json();
         if(!json?.imports)
         { throw new Error("imports not specified in deno.json") }
-        ImportMapOriginal = json;
     }
     catch(e)
     {
@@ -49,6 +29,13 @@ const ImportMapReload =async()=>
         }
     });
 
+    const mapKey = (Configuration.Spoof.startsWith("/") ? Configuration.Spoof.substring(1) : Configuration.Spoof)+"/";
+    if(!json.imports[mapKey])
+    {
+        console.log(`"${mapKey}" specifier not defined in import map`);
+    }
+    json.imports[mapKey] = Configuration.Spoof+"/";
+
     if(!json.imports["react"])
     {
         console.log(`"react" specifier not defined in import map`);
@@ -60,14 +47,15 @@ const ImportMapReload =async()=>
 
 type CustomHTTPHandler = (inReq:Request, inURL:URL, inExt:string|false, inMap:{imports:Record<string, string>}, inConfig:Configuration)=>void|false|Response|Promise<Response|void|false>;
 type CustomRemapper = (inImports:Record<string, string>, inConfig:Configuration)=>Record<string, string>;
-type Configuration     = {Proxy:string, Allow:string, Reset:string, SWCOp:SWCW.Options, Serve:CustomHTTPHandler, Shell:CustomHTTPHandler, Remap:CustomRemapper};
+type Configuration = {Proxy:string, Spoof:string, Allow:string, Reset:string, SWCOp:SWCW.Options, Serve:CustomHTTPHandler, Shell:CustomHTTPHandler, Remap:CustomRemapper};
-type ConfigurationArgs = {Proxy?:string, Allow?:string, Reset?:string, SWCOp?:SWCW.Options, Serve?:CustomHTTPHandler, Shell?:CustomHTTPHandler, Remap?:CustomRemapper};
+type ConfigurationArgs = {Proxy?:string, Spoof?:string, Allow?:string, Reset?:string, SWCOp?:SWCW.Options, Serve?:CustomHTTPHandler, Shell?:CustomHTTPHandler, Remap?:CustomRemapper};
 let Configuration:Configuration =
 {
     Proxy: new URL(`file://${Deno.cwd().replaceAll("\\", "/")}`).toString(),
     Allow: "*",
     Reset: "/clear-cache",
-    async Serve(inReq, inURL, inExt, inMap, inConfig){},
+    Spoof: "/@able",
+    Serve(inReq, inURL, inExt, inMap, inConfig){},
     Remap: (inImports, inConfig)=>
     {
         const reactURL = inImports["react"];
@@ -93,8 +81,8 @@ let Configuration:Configuration =
                     <div id="app"></div>
                     <script type="importmap">${JSON.stringify(inMap)}</script>
                     <script type="module">
-                        import Mount from "${import.meta.resolve("./boot.tsx")}";
+                        import Mount from "${inConfig.Spoof}/boot-browser.tsx";
-                        Mount("#app", "entry");
+                        Mount("#app", "${parts[1]??"/app.tsx"}");
                     </script>
                 </body>
             </html>`, {status:200, headers:{"content-type":"text/html"}});
@@ -139,85 +127,7 @@ export const Transpile =
         ImportMapReload();
         return size;
     },
-    /**
+    Fetch: async function(inPath:string, inKey:string, inCheckCache=true)
-     * Converts dynamic module imports in to static, also can resolve paths with an import map
-     */
-    async Patch(inPath:string, inKey:string, inMap?:DenoConfig)
-    {
-        const check = this.Cache.get(inKey);
-        if(check)
-        {
-            return check;
-        }
-
-        let file, text;
-        try
-        {
-            file = await fetch(inPath);
-            text = await file.text();
-        }
-        catch(e)
-        {
-            return false;
-        }
-
-        const remap = inMap ? (inPath:string)=>
-        {
-            const match = inMap.imports[inPath];
-            if(match)
-            {
-                return match;
-            }
-            else if(inPath.includes("/"))
-            {
-                let bestKey = "";
-                let bestLength = 0;
-                Object.keys(inMap.imports).forEach((key, i, arr)=>
-                {
-                    if(key.endsWith("/") && inPath.startsWith(key) && key.length > bestLength)
-                    {
-                        bestKey = key;
-                        bestLength = key.length;
-                    }
-                });
-                if(bestKey)
-                {
-                    return inMap.imports[bestKey]+inPath.substring(bestKey.length);
-                }
-            }
-            return inPath;
-        }
-        : (inPath:string)=>inPath;
-        let match, regex;
-        let convertedBody = text;
-
-        // remap static imports
-        regex = /from\s+(['"`])(.*?)\1/g;
-        while ((match = regex.exec(text)))
-        {
-          const importStatement = match[0];
-          const importPath = match[2];
-          convertedBody = convertedBody.replace(importStatement, `from "${remap(importPath)}"`);
-        }
-
-        // convert dynamic imports into static (to work around deno deploy)
-        const staticImports = [];
-        regex = /(?<![\w.])import\(([^)]+)(?!import\b)\)/g;
-        while ((match = regex.exec(text)))
-        {
-            const importStatement = match[0];
-            const importPath = remap(match[1].substring(1, match[1].length-1));
-            const moduleName = `_dyn_${staticImports.length}` as string;
-
-            staticImports.push(`import ${moduleName} from ${importPath};`);
-            convertedBody = convertedBody.replace(importStatement, `Promise.resolve(${moduleName})`);
-        }
-        convertedBody = staticImports.join("\n") + convertedBody;
-        
-        inKey && this.Cache.set(inKey, convertedBody);
-        return convertedBody;
-    },
-    async Fetch(inPath:string, inKey:string, inCheckCache=true)
     {
         const check = this.Cache.get(inPath);
         if(check && inCheckCache)
@@ -243,19 +153,6 @@ export const Transpile =
     }
 };
 
-
-export const ExtensionPrefix =(string:string, suffix:string)=>
-{
-    const lastDotIndex = string.lastIndexOf(".");
-    if (lastDotIndex === -1) {
-        return string;
-    }
-    
-    const prefix = string.substring(0, lastDotIndex);
-    const suffixString = string.substring(lastDotIndex + 1);
-    return prefix + "." + suffix + "." + suffixString;
-};
-
 export const Extension =(inPath:string)=>
 {
     const posSlash = inPath.lastIndexOf("/");
@@ -271,7 +168,7 @@ export const Configure =(config:ConfigurationArgs)=>
 
 await ImportMapReload();
 await SWCW.default();
-const server = Deno.serve({port:parseInt(Deno.env.get("port")||"8000")}, async(req: Request)=>
+HTTP.serve(async(req: Request)=>
 {
     const url:URL = new URL(req.url);
     const ext = Extension(url.pathname);
@@ -295,30 +192,19 @@ const server = Deno.serve({port:parseInt(Deno.env.get("port")||"8000")}, async(r
     {
         let code;
         let path;
-        let file;
+        if(url.pathname.startsWith(Configuration.Spoof+"/"))
-        if( req.headers.get("user-agent")?.startsWith("Deno") || url.searchParams.has("deno") )
         {
-            try
+            const clipRoot = import.meta.url.substring(0, import.meta.url.lastIndexOf("/"));
+            const clipPath = url.pathname.substring(url.pathname.indexOf("/", 1));
+            if(clipPath.startsWith("/boot-"))
             {
-                path = Configuration.Proxy + ExtensionPrefix(url.pathname, "deno");
+                path = clipRoot+"/boot-browser.tsx";
-                console.log("looking for", path);
-                file = await fetch(path) as Response;
-                if(file.ok)
-                {
-                    code = await file.text();
             }
             else
             {
-                    throw new Error("404")
+                path = clipRoot + clipPath;
-                }
-            }
-            catch(e)
-            {
-                path = Configuration.Proxy + url.pathname;
-                console.log("falling back to", path);
-                file = await fetch(path);
-                code = await file.text();
             }
+            code = await Transpile.Fetch(path, url.pathname, true);
         }
         else
         {
@@ -349,7 +235,8 @@ const server = Deno.serve({port:parseInt(Deno.env.get("port")||"8000")}, async(r
         {
             const type = MIME.typeByExtension(ext);
             const file = await fetch(Configuration.Proxy + url.pathname);
-            return new Response(file.body, {headers:{...headers, "content-type":type||""}});
+            const text = await file.text();
+            return new Response(text, {headers:{...headers, "content-type":type||""}});
         }
         catch(e)
         {

things.md

@@ -1,56 +0,0 @@
-# Outpost
-
-## Deno Deploy
-```
-accept:  */*
-accept-encoding:  gzip, br
-accept-language:  *
-cdn-loop:  deno;s=deno;d=ah40t9m8n54g
-host:  bad-goat-66.deno.dev
-user-agent:  Deno/1.34.1
-```
-
-## Deno
-```
-accept:  */*
-accept-encoding:  gzip, br
-accept-language:  *
-host:  bad-goat-66.deno.dev
-user-agent:  Deno/1.34.3
-```
-
-## Edge
-```
-accept:  text/html,application/xhtml+xml,application/xml;q=0.9,image/webp,image/apng,*/*;q=0.8,application/signed-exchange;v=b3;q=0.7
-accept-encoding:  gzip, deflate, br
-accept-language:  en-US,en;q=0.9
-host:  bad-goat-66.deno.dev
-referer:  https://dash.deno.com/
-sec-ch-ua:  "Microsoft Edge";v="117", "Not;A=Brand";v="8", "Chromium";v="117"
-sec-ch-ua-mobile:  ?0
-sec-ch-ua-platform:  "Windows"
-sec-fetch-dest:  iframe
-sec-fetch-mode:  navigate
-sec-fetch-site:  cross-site
-upgrade-insecure-requests:  1
-user-agent:  Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/117.0.0.0 Safari/537.36 Edg/117.0.0.0
-```
-
-## Firefox
-```
-accept:  text/html,application/xhtml+xml,application/xml;q=0.9,image/avif,image/webp,*/*;q=0.8
-accept-encoding:  gzip, deflate, br
-accept-language:  en-US,en;q=0.5
-host:  bad-goat-66.deno.dev
-sec-fetch-dest:  document
-sec-fetch-mode:  navigate
-sec-fetch-site:  cross-site
-te:  trailers
-upgrade-insecure-requests:  1
-user-agent:  Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:109.0) Gecko/20100101 Firefox/114.0
-```
-
-When a requet comes in:
-- if its for a transpile-able document:
-  - if its a request from deno:
-    -