.vscode/launch.json

@@ -0,0 +1,24 @@
+{
+    // Use IntelliSense to learn about possible attributes.
+    // Hover to view descriptions of existing attributes.
+    // For more information, visit: https://go.microsoft.com/fwlink/?linkid=830387
+    "version": "0.2.0",
+    "configurations": [
+
+        {
+            "request": "launch",
+            "name": "Launch Program",
+            "type": "node",
+            "cwd": "${workspaceFolder}",
+            "env": {},
+            "runtimeExecutable": "deno",
+            "runtimeArgs": [
+                "-Ar",
+                "--unstable",
+                "--inspect-brk",
+                "app.js"
+            ],
+            "attachSimplePort": 9229
+        }
+    ]
+}

app.js

@@ -1,378 +1,128 @@
-/** @import * as TYPES from "./graph/types.ts" */
-import * as FSHandle from "./store-directory-handle.js";
+import DB from "./db.js";
 
-import Styles from "./styles.js";
-const {DOM, Div, Tag} = Styles;
+const Pass = DB({path:"./db_pass.csv", cols:6, load(i, part, desk, user, role, work, data){
+    return [i.toString(), {part, desk, user, role, work, data}];
+}});
 
-async function PickHandle()
-{
-    handle = await showDirectoryPicker();
-    await FSHandle.setDirectoryHandle(handle);
-    await LoadHandleFiles();
-}
-async function LoadHandleFiles()
-{
-    console.log("fetching room.js", handle);
-    if(handle)
+await Pass.load();
+const p1 = Pass.find("0");
+console.log("Pass", p1);
+
+
+/** @typedef {{name:string, time:number, work:WorkData[], need:string[], make:string[]}} PartData */
+const Part = DB({
+    path:"./db_part.csv",
+    cols:2,
+    load:(_i, id, name)=>[id, /**@type{PartData}*/({
+        name,
+        time:0,
+        work:[],
+        need:[],
+        make:[]
+    })],
+});
+
+/**@typedef {{part:string, user:string, time:number, data:string}} WorkData*/
+const Work = DB({
+    path:"./db_work.csv",
+    cols:4,
+    load(_i, part, user, time, data)
     {
-        try
+        const parsedTime = parseInt(time);
+        /** @type {WorkData} */
+        const workObj = {part, user, time:parsedTime, data};
+        const partObj = Part.list[part];
+        if(parsedTime > partObj.time)
         {
-            const module = await import("./graph/room.js"+"?bust="+Math.random());
-            /** @type {Record<string, TYPES.GraphParts>} */
-            const read = module.default();
-
-            for(const roomKey in read)
-            {
-                const room = read[roomKey]
-                for(const pass in room.Pass)
-                {
-                    await room.Pass[pass].load();
-                }
-            }
-
-            rooms.val = read;
-        }
-        catch(e)
-        {
-            console.log("the handle exists, but the request failed. the service work must not be ready yet.", e)
-            rooms.val = {};
-        }
-    }
-    else
-    {
-        console.log("no fs handle has been set, cannot get room graph")
-        rooms.val = {};
-    }
-}
-
-/** @type {Van.State<Record<string, TYPES.GraphParts>>} */
-const rooms = van.state({});
-let handle = await FSHandle.getDirectoryHandle();
-await LoadHandleFiles();
-
-
-
-/** @type {Van.State<TYPES.User|false>} */
-const loggedIn = van.state(false);
-
-const blocking = van.state(false);
-
-const showDesks = van.state(true, "desks");
-
-/** @type {(inParts:Record<string, TYPES.Part>, inPasses:Record<string, TYPES.Pass>)=>HTMLElement} */
-function Parts(inParts, inPasses)
-{
-    const rows = [];
-    
-    const row = [DOM.th()]
-    for(const pass in inPasses)
-    {
-        row.push(DOM.th(inPasses[pass].name));
-    }
-    rows.push(DOM.thead(row));
-
-    Object.entries(inParts).map(([part_id, part])=>{
-
-        const row = [DOM.th(part.name)];
-        for(const [pass, data] of part.pass)
-        {
-            row.push(DOM.td.Part(data.work.map(w=>Div.Plain(w[1]) )))
-        }
-        rows.push(DOM.tr(row))
-    });
-
-    return DOM.table.GapVertical(rows);
-}
-
-//const deskRender = van.state(0);
-
-/** @type {(part:TYPES.Part, pass:TYPES.Pass, closeHandler:()=>void)=>HTMLElement} */
-function PartEditor(part, pass, closeHandler)
-{
-    const partPass = part.pass?.get(pass);
-
-    const hist = van.state(false);
-    const edit = van.state(false);
-
-    const upper = ()=>{
-        if(partPass?.work.length)
-        {
-            return DOM.div(
-                DOM.button(
-                    {
-                        onclick()
-                        {
-                            hist.val=!hist.val;
-                        }
-                    }, ()=>(hist.val ? "hide" : "show")+" changes"
-                ),
-                hist.val ? partPass.work.map(w=>{
-                    const date = new Date(w[0]);
-                    return DOM.div(`${date.getMonth()}/${date.getDate()}`, DOM.strong(w[1]), w[2].name);
-                }) : ""
-            );
+            partObj.time = parsedTime;
+            partObj.work.unshift(workObj);
         }
         else
         {
-            return "";
+            partObj.work.push(workObj);
         }
+        return ["", workObj];
     }
+});
 
-    const lower = ()=>
+/**@type {(work:WorkData)=>void} */
+const WorkMake =(work)=>
+{
+    const part = Part.find(work.part);
+    part.work.unshift(work);
+    part.time = work.time;
+    const itr = deskId=>Scan(Desk.find(deskId));
+    part.need.forEach(itr);
+    part.make.forEach(itr);
+};
+
+/** @typedef {"all"|"one"} DeskMode*/
+/** @typedef {[need:Record<string, number>, make:string[], ...role:string[]]} DeskJSON */
+/** @typedef {{name:string, mode:DeskMode, need:Record<string, number>, make:string[], role:string[]}} DeskData */
+
+/** @type {(desk:DeskData)=>[dirtyNeed:string[], dirtyMake:string[]]} */
+const Scan =(desk)=>
+{
+    const need = Object.keys(desk.need);
+    const make = desk.make;
+
+    const dirtyNeed = [];
+    const dirtyMake = [];
+
+    let makeMin = Infinity;
+    let needMax = -Infinity;
+
+    for(let i=0; i<need.length; i++)
     {
-        return DOM.div(
-            ()=>{
-                return loggedIn.rawVal ? DOM.button(
-                    {onclick(){edit.val = !edit.val;}},
-                    ()=>(edit.val ? "cancel" : "make") + " changes"
-                ) : DOM.p("log in to make changes")
-            },
-            ()=>{
-                const textarea = DOM.textarea()
-                return edit.val ? DOM.div(
-                    textarea,
-                    DOM.button({
-                        onclick(){
-                            if(loggedIn.rawVal && partPass)
-                            {
-                                blocking.val = true;
-                                partPass.make(loggedIn.rawVal, textarea.value).then(()=>{
-                                    blocking.val = false;
-                                    //deskRender.val++;
-                                })
-                            }
-                            else
-                            {
-                                return false;
-                            }
-                        }
-                    }, "save changes")
-                ) : ""
-            }
-        )
+        const id = need[i];
+        const part = Part.find(id);
+        if(part.time > needMax) needMax = part.time;
     }
 
-    const self = DOM.div(
-        upper,
-        ()=>DOM.button({onclick(e){e.stopPropagation(); closeHandler(this.parentElement)}}, "close"),
-        DOM.div(
-            ()=>{
-                if(partPass)
-                {
-                    return partPass.work.find((w)=>w[0] == partPass.time)?.[1] || ""
-                }
-                return "(no data yet)";
-            }
-        ),
-        lower,
-    );
+    for(let i=0; i<make.length; i++)
+    {
+        const id = make[i];
+        const part = Part.find(make[i]);
+        if(part.time < makeMin) makeMin = part.time;
+        if(part.time < needMax)
+        {
+            dirtyMake.push(id);
+        } 
+    }
 
-    return self;
-}
-
-/** @type {(inDesks:Record<string, TYPES.Desk>)=>HTMLElement} */
-function Desks(inDesks)
-{
-    return Div.PartGroup(
-        Object.entries(inDesks).map(([desk_id, desk])=>{
-
-            //loggedIn.val;
-
-            //deskRender.val;
-            //console.log("reredering desk", desk.name);
-
-            if (loggedIn.val)
-            {
-                let userInRole = false;
-                for(const role of desk.role)
-                {
-                    if(role.user.includes(loggedIn.val))
-                    {
-                        userInRole = true;
-                    }
-                }
-                if(!userInRole)
-                {
-                    return null;
-                }
-            }
-
-
-            const work = [];
-            for(const [pass, scan] of desk.pass)
-            {
-
-                // at least one but not all need fields are empty
-                const caution = scan.need_empty.length>0 && scan.need_empty.length<desk.need.length;
-
-                work.push(DOM.tr(
-                    DOM.td(pass.name),
-                    desk.need.map((part, index, array)=>
-                    {
-                        const partPass = part.pass.get(pass);
-                        if(!partPass){ return null }
-                        const latest = partPass.work.find(t=>t[0] == partPass.time)?.[1];
-
-                        const attributes = {};
-
-                        if(latest)
-                        {
-                            attributes.class = Tag("PartGood")
-                        }
-                        else
-                        {
-                            attributes.class = Tag("PartEmpty")
-                        }
-
-                        if(scan.need_dirty.includes(index))
-                        {
-                            attributes.class = Tag("PartDirty")
-                        }
-
-                        return DOM.td(
-                            Div.Part(
-                                attributes,
-                                latest
-                            )
-                        );
-                    }),
-                    DOM.td(
-                        Div.Icon("⇉"),
-                        scan.due_date ? Div.Part(
-                            scan.due_date.toLocaleDateString(),
-                            scan.due_date.toLocaleTimeString()
-                        ) : " "
-                    ),
-                    desk.make.map((part, index, array)=>
-                    {
-                        const partPass = part.pass.get(pass);
-                        if(!partPass){ return null }
-                        const latest = partPass.work.find(t=>t[0] == partPass.time)?.[1];
-                        
-                        const attr = "data-editing"
-                        function close(editor){
-                            editor.remove();
-                            this.setAttribute(attr, "false");
-                        }
-
-                        const attributes = {
-                            onclick(){
-                                
-                                const check = this.getAttribute(attr);
-                                if(check !== "true")
-                                {
-                                    this.setAttribute(attr, "true");
-                                    this.appendChild(PartEditor(part, pass, close.bind(this)));
-                                }
-                            }
-                        };
-                        
-                        if(latest)
-                        {
-                            attributes.class = Tag("PartGood")
-                        }
-                        else
-                        {
-                            attributes.class = Tag("PartEmpty")
-                        }
-
-                        if( (desk.need.length==0 && !latest) || scan.make_dirty.includes(index))
-                        {
-                            
-                            if(!latest && caution)
-                            {
-                                attributes.class = Tag("PartCaution")
-                            }
-                            else
-                            {
-                                attributes.class = Tag("PartDirty");
-                            }
-                        }   
-
-                        return DOM.td(
-                            Div.Part(
-                                attributes,
-                                latest
-                            )
-                        );
-                    }),
-                ))
-            }
-
-            return Div.DeskContainer(
-                DOM.h3(desk.name),
-                DOM.table.GapHorizontal(
-
-                    DOM.thead(
-                        DOM.tr(
-                            DOM.th(),
-                            desk.need.map((part, index)=>DOM.th(part.name)),
-                            DOM.th("→"),
-                            desk.make.map((part, index)=>DOM.th(part.name))
-                        )
-                    ),
-                    work
-                )
-            )
-
-
-        }),
-    )
-}
-
-/** @type {(room_id:string, graphParts:TYPES.GraphParts)=>HTMLElement} */
-function Room(room_id, graphParts)
-{
-    const rerender = van.state(0);
-    blocking.val;
-
-    return Div.Plain(
-
-        Div.Plain("Users:"),
-        Div.PartGroup(
-            Object.entries(graphParts.User).map(([user_id, user])=>{
-                return Div.Part(
-                        DOM.div.Plain(user.name),
-                        ()=>{
-                            return DOM.button.Plain(
-                                {onclick(){
-                                    loggedIn.val = (loggedIn.val == user) ? false : user;
-                                }},
-                                loggedIn.val == user ? "this is me" : "impersonate"
-                            )
-                        },
-                )
-
-            })
-        ),
-
-        ()=>{
-            return DOM.button({onclick(){
-                showDesks.val = !showDesks.val;
-            }}, showDesks.val ? "Show Parts" : "Show Desks")
-        },
-
-        ()=>{
-            rerender.val;
-            return showDesks.val ? Desks(graphParts.Desk) : Parts(graphParts.Part, graphParts.Pass);
-        },
-
-
-        ()=>{
-            return blocking.val ? Div.BlockScreen() : null
+    for(let i=0; i<need.length; i++)
+    {
+        const id = need[i];
+        const part = Part.find(id);
+        if(part.time > makeMin)
+        {
+            dirtyNeed.push(id);
         }
+    }
 
-    )
-}
+    console.log("scan", dirtyNeed, dirtyMake);
+    return [dirtyNeed, dirtyMake];
+};
 
-function App()
-{
-    return Div.Plain(
-        DOM.button({onclick:PickHandle}, "Pick Directory"),
-        Object.entries(rooms.val).map(([room_id, graphParts])=>
-            Room(room_id, graphParts)
-        )
-    )
-}
+const Desk = DB({
+    path:"./db_desk.csv",
+    cols:4,
+    load(_i, id, name, mode, data)
+    {
+        /**@type {DeskJSON} */
+        const [need, make, ...role] = JSON.parse(data);
+        const deskObj = { name, mode:/**@type{DeskMode}*/(mode), need, make, role };
+        
+        make.forEach(partId=>Part.find(partId).make.push(id));
+        Object.keys(need).forEach(partId=>Part.find(partId).need.push(id));
+        Scan(deskObj);
 
-van.add(document.body, App);
+        return [id, deskObj];
+    }
+});
+
+await Part.load();
+await Work.load();
+await Desk.load();
+
+WorkMake({part:"p3", user:"u1", time:new Date().getTime(), data:"NEW!"});

db.js

@@ -0,0 +1,71 @@
+function createCSVScanner(onRow, cols) {
+  let buffer = '';
+
+  return function scanChunk(chunk) {
+    buffer += chunk;
+    const lines = buffer.split('\n');
+    buffer = lines.pop(); // Save incomplete line
+
+    for (const line of lines)
+    {
+      const fields = [];
+      let start = 0;
+      let col = 0;
+      for (let i = 0; i < line.length; i++) {
+        if (line[i] === ',' && col < cols-1) {
+          fields.push(line.slice(start, i));
+          start = i + 1;
+          col++;
+        }
+      }
+      fields.push(line.slice(start, line.length-1));
+      onRow(...fields);
+    }
+
+  };
+}
+
+async function DB(url, cols, onRow) {
+    const response = await fetch(url);
+
+    if (!response.ok) {
+        throw new Error(`HTTP error! status: ${response.status}`);
+    }
+
+    const reader = response.body.getReader();
+    const decoder = new TextDecoder("utf-8");
+
+    const scanner = createCSVScanner(onRow, cols);
+
+    while (true)
+    {
+        const { done, value } = await reader.read();
+        if (done) break;
+        const chunk = decoder.decode(value, { stream: true });
+        scanner(chunk);
+    }
+}
+
+
+const instances = {};
+/** @import DBTypes from "./types.d.ts" */
+/** @type {DBTypes.Builder} */
+export default function(params)
+{
+    const obj = {
+        list:{},
+        load(){
+            let index = 0;
+            this.list = {};
+            return DB(import.meta.resolve(params.path), params.cols, (...args)=>{
+                const [id, data] = params.load(index, ...args);
+                id && (this.list[id] = data);
+                index++;
+            });
+        },
+        find(id){return this.list[id];},
+        save(){},
+    };
+
+    return obj;
+}

db_desk.csv

@@ -0,0 +1 @@
+d1,Desk One,all,[{"p1":1, "p2":1, "p4":0},["p3"],"r1"]

db_part.csv

@@ -0,0 +1,4 @@
+p1,Part 1
+p2,Part 2
+p3,Part 3
+p4,Part Empty

db_pass.csv

@@ -0,0 +1 @@
+./db_part.csv,./db_desk.csv,./db_user.csv,./db_role.csv,./db_work.csv,August 2025

db_user.csv

@@ -0,0 +1 @@
+u1,seth trowbridge

db_work.csv

@@ -0,0 +1,5 @@
+p1,u1,1,{"data":"value1"}
+p1,u1,2,{"data":"value2"}
+p2,u2,3,{"key1":"value3"}
+p2,u2,4,{"key1":"value4"}
+p3,u2,3,{"key1":"value5"}

deep/mock-user-folder/graph/room.js

@@ -1,43 +0,0 @@
-//@ts-check
-import CreateAllRooms, {Room} from "../../graph/graph.js";
-
-const user = {
-    u1:"Seth T",
-    u4:"Sarah S",
-    u5:"Adam M",
-    u6:"Matt Y",
-    u7:"Seth F",
-    u8:"Brittany F"
-};
-
-export default CreateAllRooms({
-    room_01:Room({
-        user,
-        role:{
-              dev:["Development", "u1"],
-            write:["Writing", "u5"],
-            admin:["Admin", "u4"]
-        },
-        part:{
-            p1:["Page title"],
-            p2:["Page slug"],
-            p3:["Page preview"],
-            p4:["Page Project"],
-            p5:["Page Corrections", "loop"],
-        },
-        desk:{
-            d1:["Write page metas",   ["admin", "write"], {                }, "p1", "p2"],
-            d2:["Build Page preview", ["admin", "dev"  ], {p1:1, p2:1, p5:4}, "p3", "p4"],
-            d3:["Proof Page",         ["admin", "write"], {p3:1,           }, "p5"      ]
-        },
-        pass:{
-            pass_01:["January"],
-            //pass_02:["February"],
-            //pass_03:["March"],
-            //pass_04:["April"],
-            //pass_05:["May"],
-            //pass_06:["June"],
-            //pass_07:["July"],
-        }
-    })
-});

deno.json

@@ -1,8 +1,5 @@
 {
-    "compilerOptions":
-    {
-        "checkJs": true,
-            "lib": ["deno.window", "DOM"],
-          "types": ["https://treetopflyer.github.io/gale/types.d.ts"]
+    "compilerOptions": {
+        "checkJs": true
     }
 }

graph/graph.js

@@ -1,314 +0,0 @@
-/** @import * as TYPES from "./types.ts" */
-import * as FSAccess from "../store-directory-handle.js";
-
-export const noop = "no-op";
-
-/** @type {TYPES.GraphBuilder} */
-export function Room({user, role, part, desk, pass})
-{
-
-// mutate users
-    /** @type {Record<string, TYPES.User>} */
-    //@ts-ignore
-    const UserList = user;
-    for(let userId in user)
-    {
-        const name = user[userId];
-
-        UserList[userId] = {name, id:userId, desk:new Set()};
-    }
-
-// mutate roles
-    /** @type {Record<string, TYPES.Role>} */
-    //@ts-ignore
-    const RoleList = role;
-    for(let roleId in role)
-    {
-        const [name, ...userIds] = role[roleId];
-        RoleList[roleId] = {name, id:roleId, user:userIds.map(uId=>UserList[/**@type{string}*/(uId)])};
-    }
-
-// mutate parts
-    /** @type {Record<string, TYPES.Part>} */
-    //@ts-ignore
-    const PartList = part;
-    for(let partId in part)
-    {
-        const [name, loop] = part[partId];
-
-        PartList[partId] = /** @type {TYPES.Part} */({name, id:partId, need:[], make:[], pass:new Map(), loop:loop});
-    }
-
-// mutate desks
-    /** @type {Record<string, TYPES.Desk>} */
-    //@ts-ignore
-    const DeskList = desk;
-    for(let deskId in desk)
-    {
-        const [name, roleIDs, needObj, ...makePartIDs] = desk[deskId];
-        /** @type {TYPES.Part[]}*/ const need =[];
-        /** @type {number[]}*/ const time =[];
-
-        /** @type {TYPES.Desk} */
-        const deskObj = {
-            name,
-            id:deskId,
-            need,
-            time,
-            make:[],
-            role:[],
-            pass:new Map()
-        };
-
-        for(const partId in needObj)
-        {   
-            const part = PartList[partId];
-            need.push(part);
-            part.need.push(deskObj);
-            time.push(needObj[partId]);
-        }
-
-        deskObj.role = roleIDs.map(roleId=>
-        {
-            const role = RoleList[/**@type{string}*/(roleId)];
-            role.user.forEach(u =>u.desk.add(deskObj));
-            return role;
-        }); 
-
-        deskObj.make = makePartIDs.map( partId=>
-        {
-            const part = PartList[/**@type{string}*/(partId)];
-            part.make.push(deskObj);
-            return part;
-        } )
-
-        DeskList[deskId] = deskObj;
-    }
-
-// Apply passes
-    /** @type {Record<string, TYPES.Pass>} */
-    //@ts-ignore
-    const PassList = pass;
-    for(let passID in pass)
-    {
-        /** @type {TYPES.Pass} */
-        const passObj = {
-            name: pass[passID][0],
-            id:passID,
-            path:passID,
-            async load(){
-
-                // make room for this pass to each part and desk
-                Object.values(PartList).forEach((partObj)=>
-                {
-                    partObj.pass.set(passObj, {time:0, work:[], async make(user, data)
-                    {
-                        this.time = Date.now();
-
-                        const handle = await FSAccess.getDirectoryHandle();
-                        const path = ["store", context.Path, passID, user.id+".json"];
-                        let text = await FSAccess.Read(handle, path) || "{}";
-                        /** @type {TYPES.UserPassFile} */
-                        const json = JSON.parse(text);
-
-                        let field = json[partObj.id];
-                        if(!field)
-                        {
-                            field = [];
-                            json[partObj.id] = field;
-                        }
-                        field.push([this.time, data]);
-                        text = JSON.stringify(json, null, 2);
-                        await FSAccess.Write(handle, path, text);
-                        
-                        this.work.push(/** @type {TYPES.Work}*/([this.time, data, user]));
-                        partObj.make.forEach((arg)=>{Scan(arg, passObj)});
-                        partObj.need.forEach((arg)=>{Scan(arg, passObj)});
-                    }});
-                });
-                Object.values(DeskList).forEach((deskObj)=>
-                {
-                    deskObj.pass.set(passObj, {need:[], make:[]});
-                });
-                
-
-                // actually load the pass
-                const userData = Object.entries(UserList);
-                for(let i=0; i<userData.length; i++)
-                {
-                    const [userID, userObject] = userData[i];
-                    try
-                    {   
-                        const handle = await FSAccess.getDirectoryHandle();
-                        const text = await FSAccess.Read(handle, ["store", context.Path, passID, userID+".json"]);
-                        /** @type {TYPES.UserPassFile} */
-                        const json = JSON.parse(text);
-                        
-                        Object.entries(json).forEach(([partID, payload])=>{
-
-                            let latest = 0;
-                            payload.forEach((condensedWork)=>{
-                                if(condensedWork[0] > latest)
-                                {
-                                    latest = condensedWork[0];
-                                }
-                                condensedWork[2] = userObject;
-                            });
-
-                            const passCheck = PartList[partID].pass.get(this);
-                            if(passCheck)
-                            {
-                                if(latest > passCheck.time)
-                                {
-                                    passCheck.time = latest;
-                                }
-                                //payload.sort()
-                                passCheck.work = /** @type {TYPES.Work[]}*/(payload);
-                            }
-
-                        })
-                    }
-                    catch(e)
-                    {
-                        console.warn(`No data for user ${userID} on pass ${passID} yet.`)
-                        continue;
-                    }
-
-                }
-
-                // update the graph
-                Object.values(DeskList).forEach((deskObj)=>Scan(deskObj, passObj));
-
-                this.live = true;
-            },
-            dump(){
-                Object.values(PartList).forEach((partObj)=>partObj.pass.delete(passObj));
-                Object.values(DeskList).forEach((deskObj)=>deskObj.pass.delete(passObj));
-                this.live = false;
-            },
-            live:false
-        };
-
-        PassList[passID] = passObj;
-    }
-
-    const context = {
-        Path:"",
-        Desk:DeskList,
-        Part:PartList,
-        User:UserList,
-        Role:RoleList,
-        Pass:PassList
-    }
-
-    return context;
-}
-
-/** @type {TYPES.MassBuilder} */
-export default function MassBuild(params)
-{
-    return ()=>{
-        Object.entries(params).forEach( ([roomFolderName, roomData])=>
-        {
-            roomData.Path = roomFolderName;
-        });
-        return params;
-    }
-}
-
-/** @type {TYPES.Scanner} */
-const Scan =(desk, pass)=>
-{
-    const dirtyNeed = [];
-    const dirtyMake = [];
-
-    const emptyNeed = [];
-    const emptyMake = [];
-
-    let makeMin = Infinity;
-    let needMax = -Infinity;
-    
-    // added for estimation
-    let estMin = Infinity;
-    let estMax = -Infinity;
-    let estSum = 0;
-
-/*
-
-Loop parts:
-- always considered clean when the leading value is a no-op
-- as a need, considered clean when empty
-
-*/
-
-    /** @type {(part:TYPES.Part)=>[time:number, value:string|undefined, part:TYPES.Part]} */
-    const lookup =(part)=>
-    {
-        const partPass = part.pass.get(pass);
-        const partPassTime = partPass?.time || 0;
-        const partPassValue = partPass?.work.find(t=>t[0] == partPassTime)?.[1];
-        return [partPassTime, partPassValue, part];
-    }
-
-    // update needMax
-    for(let i=0; i<desk.need.length; i++)
-    {
-        const [time, value, part] = lookup(desk.need[i]);
-
-        if(part.loop)
-        {
-            if(!value || value == noop)
-            {
-                continue;
-            }
-        }
-
-        if(time > needMax) needMax = time;
-        if(!time) emptyNeed.push(i);
-    }
-
-    // update makeMin AND dirtyMakes
-    for(let i=0; i<desk.make.length; i++)
-    {
-        const [time] = lookup(desk.make[i]);
-
-        if(time < makeMin) makeMin = time;
-        if(time < needMax) dirtyMake.push(i);
-        if(!time) emptyMake.push(i) 
-
-    }
-
-    // dirtyNeeds
-    for(let i=0; i<desk.need.length; i++)
-    {
-        const [time, value, part] = lookup(desk.need[i]);
-
-        if(part.loop)
-        {
-            if(!value || value == noop)
-            {
-                continue;
-            }
-        }
-
-        if(time > makeMin)
-        {
-            dirtyNeed.push(i);
-
-            // estimation
-            if(time < estMin) estMin = time;
-            const allottedTime = desk.time[i] * 1000 * 60 * 60;
-            const projectedTime = time + allottedTime;
-            estSum += allottedTime;
-            if(projectedTime > estMax) estMax = projectedTime;
-        }
-    }
-    
-    estSum += estMin;
-    let stamp = estSum;
-    if(estMax > estSum)
-    {
-        stamp = estMax;
-    }
-    desk.pass.set(pass, {need_dirty:dirtyNeed, make_dirty:dirtyMake, need_empty:emptyNeed, make_empty:emptyMake, due_date:isFinite(stamp) ? new Date(stamp) : undefined})
-};

graph/types.ts

@@ -1,44 +0,0 @@
-export type User = {name:string, id:string, desk:Set<Desk>};
-export type Role = {name:string, id:string, user:User[]};
-export type Desk = {name:string, id:string, need:Part[], time:number[], make:Part[], pass:Map<Pass, Scan>, role:Role[]};
-export type Pass = {name:string, id:string, path:string, live:boolean, load:()=>Promise<void>, dump:()=>void};
-export type Part = {name:string, id:string, pass:Map<Pass, {time:number, work:Work[], make:(user:User, data:string)=>Promise<void>}>, need:Desk[], make:Desk[], loop?:boolean};
-export type Work = [time:number, data:string, user:User];
-export type Scan = {need_dirty:number[], make_dirty:number[], need_empty:number[], make_empty:number[], due_date?:Date}
-
-export type GraphBuilder=
-<
-    Users extends Record<string, string>,
-    Roles extends Record<string, [ name:string, ...users:Array<keyof Users>]>,
-    Parts extends Record<string, [ name:string, loop?:"loop"] >,
-    Desks extends Record<string, [ name:string, roles:Array<keyof Roles>, need:Partial<Record<keyof Parts, number>>, ...make:Array<keyof Parts>]>,
->
-(
-    params:{
-        meta?:{name:string},
-        user:Users,
-        role:Roles,
-        part:Parts,
-        desk:Desks,
-        pass:Record<string, [name:string]>,
-    }
-)
-=>GraphParts
-
-
-export type GraphParts = {
-    Desk:Record<string, Desk>,
-    Part:Record<string, Part>,
-    User:Record<string, User>,
-    Role:Record<string, Role>,
-    Pass:Record<string, Pass>
-    Path:string
-}
-
-export type MassBuilder=<Params extends Record<string, GraphParts>>(rooms:Params)=>()=>{
-    [K in keyof Params]: GraphParts
-}
-
-export type UserPassFile = Record<string, Array<[time:number, data:string, user?:User]>>
-
-export type Scanner =(desk:Desk, pass:Pass)=>void;

index.html

@@ -1,57 +0,0 @@
-<html lang="en">
-<head>
-    <meta charset="UTF-8">
-    <meta name="viewport" content="width=device-width, initial-scale=1.0">
-    <title>Document</title>
-    <style>
-/* Basic CSS Reset */
-* {
-  margin: 0;
-  padding: 0;
-  box-sizing: border-box;
-}
-
-html, body {
-  height: 100%;
-  font-family: sans-serif;
-  line-height: 1.5;
-  -webkit-font-smoothing: antialiased;
-  -moz-osx-font-smoothing: grayscale;
-}
-
-img, picture, video, canvas, svg {
-  display: block;
-  max-width: 100%;
-}
-
-input, button, textarea, select {
-  font: inherit;
-}
-
-a {
-  text-decoration: none;
-  color: inherit;
-}
-
-ul, ol {
-  list-style: none;
-}
-
-table {
-  border-collapse: collapse;
-  border-spacing: 0;
-}
-
-    </style>
-</head>
-<body>
-    <script>
-        if ('serviceWorker' in navigator) {
-            navigator.serviceWorker.register('/service-worker.js', {type:"module"})
-            .then(reg => console.log('Service Worker registered:', reg))
-            .catch(err => console.error('Service Worker registration failed:', err));
-        }
-    </script>
-    <script type="module" src="https://treetopflyer.github.io/gale/boot.js?entry=/app.js"></script>
-</body>
-</html>

mock-user-folder/graph/room.js

@@ -1,43 +0,0 @@
-//@ts-check
-import CreateAllRooms, {Room} from "../../graph/graph.js";
-
-const user = {
-    u1:"Seth T",
-    u4:"Sarah S",
-    u5:"Adam M",
-    u6:"Matt Y",
-    u7:"Seth F",
-    u8:"Brittany F"
-};
-
-export default CreateAllRooms({
-    room_01:Room({
-        user,
-        role:{
-              dev:["Development", "u1"],
-            write:["Writing", "u5"],
-            admin:["Admin", "u4"]
-        },
-        part:{
-            p1:["Page title"],
-            p2:["Page slug"],
-            p3:["Page preview"],
-            p4:["Page Project"],
-            p5:["Page Corrections", "loop"],
-        },
-        desk:{
-            d1:["Write page metas",   ["admin", "write"], {                }, "p1", "p2"],
-            d2:["Build Page preview", ["admin", "dev"  ], {p1:1, p2:1, p5:1}, "p3", "p4"],
-            d3:["Proof Page",         ["admin", "write"], {p3:1,           }, "p5"      ]
-        },
-        pass:{
-            pass_01:["January"],
-            //pass_02:["February"],
-            //pass_03:["March"],
-            //pass_04:["April"],
-            //pass_05:["May"],
-            //pass_06:["June"],
-            //pass_07:["July"],
-        }
-    })
-});

mock-user-folder/store/room_01/pass_01/u4.json

@@ -1,14 +0,0 @@
-{
-  "p1": [
-    [
-      1762196165935,
-      "normal title"
-    ]
-  ],
-  "p2": [
-    [
-      1762196173135,
-      "normal slug"
-    ]
-  ]
-}

mock-user-folder/store/room_01/pass_02/u1.json

@@ -1,8 +0,0 @@
-{
-  "p4": [
-    [
-      1762193485093,
-      "Make made Late"
-    ]
-  ]
-}

mock-user-folder/store/room_01/pass_02/u3.json

@@ -1,8 +0,0 @@
-{
-    "p1":
-    [
-        [123456, "data"],
-        [4562358723, "more data"],
-        [789235072367, "even more data"]
-    ]
-}

mock-user-folder/store/room_01/pass_02/u5.json

@@ -1,8 +0,0 @@
-{
-  "p1": [
-    [
-      1762186057868,
-      "Need made Early"
-    ]
-  ]
-}

mock-user-folder/store/room_01/pass_03/u4.json

@@ -1,14 +0,0 @@
-{
-  "p4": [
-    [
-      1762196034794,
-      "Make made Early"
-    ]
-  ],
-  "p1": [
-    [
-      1762196047017,
-      "Need made Late"
-    ]
-  ]
-}

mock-user-folder/store/room_01/pass_04/u1.json

@@ -1,14 +0,0 @@
-{
-  "p3": [
-    [
-      1762196236384,
-      "complete 3"
-    ]
-  ],
-  "p4": [
-    [
-      1762196245327,
-      "complete 4"
-    ]
-  ]
-}

mock-user-folder/store/room_01/pass_04/u5.json

@@ -1,14 +0,0 @@
-{
-  "p1": [
-    [
-      1762196209704,
-      "complete 1"
-    ]
-  ],
-  "p2": [
-    [
-      1762196217319,
-      "complete 2"
-    ]
-  ]
-}

mock-user-folder/store/room_01/pass_05/u1.json

@@ -1,18 +0,0 @@
-{
-  "p3": [
-    [
-      1762196341950,
-      "complete 3"
-    ]
-  ],
-  "p4": [
-    [
-      1762196348950,
-      "complete 4"
-    ],
-    [
-      1762196393702,
-      "complete Later"
-    ]
-  ]
-}

mock-user-folder/store/room_01/pass_05/u5.json

@@ -1,18 +0,0 @@
-{
-  "p1": [
-    [
-      1762196328127,
-      "complete 1"
-    ]
-  ],
-  "p2": [
-    [
-      1762196335342,
-      "complete 2"
-    ],
-    [
-      1762196363079,
-      "complete Late"
-    ]
-  ]
-}

mock-user-folder/store/room_01/pass_07/u5.json

@@ -1,8 +0,0 @@
-{
-  "p1": [
-    [
-      1762201681431,
-      "underway"
-    ]
-  ]
-}

service-worker.js

@@ -1,44 +0,0 @@
-import * as FSAccess from "./store-directory-handle.js";
-
-self.addEventListener('install', ()=>{console.log("SW INSTALL"); return self.skipWaiting()}); // Activate worker immediately);
-self.addEventListener('activate', ()=>{
-  console.log("SW ACTIVATE");
-  return self.clients.claim();
-}); // Become available to all pages);
-self.addEventListener('fetch', (event) =>event.respondWith(Interceptor(event)));
-
-const options = {
-  headers: {
-    'Content-Type': 'application/javascript',
-    'Cache-Control': 'no-cache'
-  }
-}
-
-/** @type {(event:{request:Request})=>Promise<Response>} */
-async function Interceptor(event)
-{
-  const url = new URL(event.request.url);
-  const pathname = url.pathname.substring(1);
-  let parts = pathname.split("/");
-
-  if(parts[0] == "graph")
-  {
-    console.log("intercept:", pathname);
-
-    const handle = await FSAccess.getDirectoryHandle();
-    const text = await FSAccess.Read(handle, parts);
-    if(text)
-    {
-      console.log("successful intercept:", pathname);
-      return new Response(text, options);
-    }
-    else
-    {
-      console.log("failed intercept:", pathname);
-    }
-
-  }
-
-  return fetch(event.request);
-
-}

store-directory-handle.js

@@ -1,109 +0,0 @@
-// 📦 IndexedDB Helper
-/** @type {()=>Promise<IDBDatabase>} */
-function openDB() {
-  return new Promise((resolve, reject) => {
-    const request = indexedDB.open('directory-handle-db', 1);
-    request.onupgradeneeded = () => {
-      request.result.createObjectStore('handles');
-    };
-    request.onsuccess = () => resolve(request.result);
-    request.onerror = () => reject(request.error);
-  });
-}
-
-// 💾 Store a directory handle
-/** @type {(handle:FileSystemDirectoryHandle)=>Promise<void>} */
-export async function setDirectoryHandle(handle) {
-  const db = await openDB();
-  const tx = db.transaction('handles', 'readwrite');
-  tx.objectStore('handles').put(handle, 'user-folder');
-  console.log("handle set", handle);
-  await tx.done;
-}
-
-
-// 📂 Retrieve a directory handle
-/** @type {()=>Promise<FileSystemDirectoryHandle|false>} */
-export async function getDirectoryHandle() {
-
-  const db = await openDB();
-  const tx = db.transaction('handles', 'readonly');
-  return new Promise((resolve, reject) => {
-    const getRequest = tx.objectStore('handles').get('user-folder');
-    getRequest.onsuccess = () => {
-      return resolve(getRequest.result);
-    }
-    getRequest.onerror = () => {
-      console.error('Error retrieving directory handle:', getRequest.error);
-      return resolve(false);
-    }
-  });
-}
-
-/** @type {(handle:FileSystemDirectoryHandle, parts:string[], create?:boolean)=>Promise<FileSystemFileHandle|false>} */
-export async function Dig(handle, parts, create=false)
-{
-  try
-  {
-    let filePointer = handle;
-    for(let i=0; i<parts.length-1; i++)
-    {
-      filePointer = await filePointer.getDirectoryHandle(parts[i], {create});
-    }
-    const leaf = await filePointer.getFileHandle(parts[parts.length-1], {create});
-    return leaf;   
-  }
-  catch(e)
-  {
-    return false
-  }
-}
-
-/** @type {(handle:FileSystemDirectoryHandle, parts:string[])=>Promise<string|false>} */
-export async function Read(handle, parts)
-{
-
-  const fileHandle = await Dig(handle, parts);
-  if(fileHandle)
-  {
-    const file = await fileHandle.getFile();
-    return await file.text();
-  }
-
-  return false;
-}
-
-/** @type {(handle:FileSystemDirectoryHandle, parts:string[], text:string)=>Promise<boolean>} */
-export async function Write(handle, parts, text)
-{
-  const fileHandle = await Dig(handle, parts, true);
-  if(fileHandle)
-  {
-    const writeable = await fileHandle.createWritable();
-    await writeable.write(text);
-    await writeable.close();
-    return true;
-  }
-  return false;
-}
-
-
-
-// // 🔐 Check or request permission
-// async function verifyPermission(handle, mode = 'readwrite') {
-//   const opts = { mode };
-//   if ((await handle.queryPermission(opts)) === 'granted') return true;
-//   if ((await handle.requestPermission(opts)) === 'granted') return true;
-//   return false;
-// }
-// 
-// 
-// // 📌 Request persistent storage
-// async function ensurePersistentStorage() {
-//   if (navigator.storage && navigator.storage.persist) {
-//     const granted = await navigator.storage.persist();
-//     console.log(granted
-//       ? '✅ Persistent storage granted.'
-//       : '⚠️ Storage may be cleared under pressure.');
-//   }
-// }

styles.js

@@ -1,64 +0,0 @@
-export default Gale({
-    Title:{
-        padding:"2rem",
-        background: "blue",
-        color:"white"
-    },
-    Plain:{},
-    PartGroup:{
-        display: `flex`,
-        flexWrap: `wrap`
-    },
-    Icon:{
-        background:"black",
-        color:"white",
-        borderRadius:"2rem",
-        fontWeight:"bolder",
-        padding:"0 0.8rem",
-        margin:"0 1rem"
-    },
-    Part:{
-        border: `1px solid black`,
-        borderRadius: `5px`,
-        padding: `0.5rem 1rem`,
-        minHeight: "2rem",
-    },
-    PartGood:{
-        background:"#009b2e",
-        color:"white",
-    },
-    PartEmpty:{
-        background:"#ddd"
-    },
-    PartDirty:{
-        background:"red",
-        color:"white",
-        fontWeight:"bold"
-    },
-    PartCaution:{
-        background:"yellow",
-        color:"black",
-    },
-    BlockScreen:{
-        position: "fixed",
-        zIndex: "9999",
-        top: "0",
-        left: "0",
-        width: "100%",
-        height: "100%",
-        background: "rgba(128, 128, 128, 0.5)"
-    },
-    DeskContainer:{
-        border: `1px solid black`,
-        borderRadius: `5px`,
-        padding: `1rem`
-    },
-    GapHorizontal:{
-        borderCollapse:"separate",
-        borderSpacing:"0.3rem 2rem",
-    },
-    GapVertical:{
-        borderCollapse:"separate",
-        borderSpacing:"2rem 0.2rem",
-    }
-});

types.d.ts

@@ -0,0 +1,16 @@
+export type Row<
+    L extends number,
+    T extends any[] = []
+> = T["length"] extends L ? T : Row<L, [string, ...T]>;
+export type Builder = <Count extends number, Loaded, Sized extends Row<Count>>(params:
+{
+    path:string,
+    cols:Count,
+    load:(index:number, ...args:Sized)=>[id:string, data:Loaded],
+    //save:(commitSave:(...args:Sized)=>Sized, id:string, data:Loaded) => Sized
+}) => {
+    list:Record<string, Loaded>,
+    find:(id:string)=>Loaded,
+    load:()=>Promise<void>,
+    save:()=>Promise<void>
+}