.vscode/launch.json

@@ -1,24 +0,0 @@
-{
-    // 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,119 +1,378 @@
-import DB from "./db.js";
+/** @import * as TYPES from "./graph/types.ts" */
+import * as FSHandle from "./store-directory-handle.js";
 
-/** @typedef {{name:string, time:number, work:WorkData[], need:string[], make:string[]}} PartData */
+import Styles from "./styles.js";
-const Part = DB({
+const {DOM, Div, Tag} = Styles;
-    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*/
+async function PickHandle()
-const Work = DB({
-    path:"./db_work.csv",
-    cols:4,
-    load(_i, part, user, time, data)
 {
-        const parsedTime = parseInt(time);
+    handle = await showDirectoryPicker();
-        /** @type {WorkData} */
+    await FSHandle.setDirectoryHandle(handle);
-        const workObj = {part, user, time:parsedTime, data};
+    await LoadHandleFiles();
-        const partObj = Part.list[part];
+}
-        if(parsedTime > partObj.time)
+async function LoadHandleFiles()
 {
-            partObj.time = parsedTime;
+    console.log("fetching room.js", handle);
-            partObj.work.unshift(workObj);
+    if(handle)
+    {
+        try
+        {
+            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
     {
-            partObj.work.push(workObj);
+        console.log("no fs handle has been set, cannot get room graph")
+        rooms.val = {};
     }
-        return ["", workObj];
 }
+
+/** @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))
     });
 
-/**@type {(work:WorkData)=>void} */
+    return DOM.table.GapVertical(rows);
-const WorkMake =(work)=>
+}
+
+//const deskRender = van.state(0);
+
+/** @type {(part:TYPES.Part, pass:TYPES.Pass, closeHandler:()=>void)=>HTMLElement} */
+function PartEditor(part, pass, closeHandler)
 {
-    const part = Part.find(work.part);
+    const partPass = part.pass?.get(pass);
-    part.work.unshift(work);
+
-    part.time = work.time;
+    const hist = van.state(false);
-    const itr = deskId=>Scan(Desk.find(deskId));
+    const edit = van.state(false);
-    part.need.forEach(itr);
+
-    part.make.forEach(itr);
+    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);
+                }) : ""
+            );
+        }
+        else
+        {
+            return "";
+        }
+    }
+
+    const lower = ()=>
+    {
+        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 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,
+    );
+
+    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)));
+                                }
+                            }
                         };
                         
-/** @typedef {"all"|"one"} DeskMode*/
+                        if(latest)
-/** @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);
+                            attributes.class = Tag("PartGood")
-    const make = desk.make;
+                        }
-
+                        else
-    const dirtyNeed = [];
-    const dirtyMake = [];
-
-    let makeMin = Infinity;
-    let needMax = -Infinity;
-
-    for(let i=0; i<need.length; i++)
                         {
-        const id = need[i];
+                            attributes.class = Tag("PartEmpty")
-        const part = Part.find(id);
-        if(part.time > needMax) needMax = part.time;
                         }
 
-    for(let i=0; i<make.length; i++)
+                        if( (desk.need.length==0 && !latest) || scan.make_dirty.includes(index))
                         {
-        const id = make[i];
+                            
-        const part = Part.find(make[i]);
+                            if(!latest && caution)
-        if(part.time < makeMin) makeMin = part.time;
-        if(part.time < needMax)
                             {
-            dirtyMake.push(id);
+                                attributes.class = Tag("PartCaution")
+                            }
+                            else
+                            {
+                                attributes.class = Tag("PartDirty");
                             }
                         }   
 
-    for(let i=0; i<need.length; i++)
+                        return DOM.td(
-    {
+                            Div.Part(
-        const id = need[i];
+                                attributes,
-        const part = Part.find(id);
+                                latest
-        if(part.time > makeMin)
+                            )
-        {
+                        );
-            dirtyNeed.push(id);
+                    }),
-        }
+                ))
             }
 
-    console.log("scan", dirtyNeed, dirtyMake);
+            return Div.DeskContainer(
-    return [dirtyNeed, dirtyMake];
+                DOM.h3(desk.name),
-};
+                DOM.table.GapHorizontal(
 
-const Desk = DB({
+                    DOM.thead(
-    path:"./db_desk.csv",
+                        DOM.tr(
-    cols:4,
+                            DOM.th(),
-    load(_i, id, name, mode, data)
+                            desk.need.map((part, index)=>DOM.th(part.name)),
-    {
+                            DOM.th("→"),
-        /**@type {DeskJSON} */
+                            desk.make.map((part, index)=>DOM.th(part.name))
-        const [need, make, ...role] = JSON.parse(data);
+                        )
-        const deskObj = { name, mode:/**@type{DeskMode}*/(mode), need, make, role };
+                    ),
+                    work
+                )
+            )
 
-        make.forEach(partId=>Part.find(partId).make.push(id));
-        Object.keys(need).forEach(partId=>Part.find(partId).need.push(id));
-        Scan(deskObj);
 
-        return [id, deskObj];
+        }),
+    )
 }
-});
 
-await Part.load();
+/** @type {(room_id:string, graphParts:TYPES.GraphParts)=>HTMLElement} */
-await Work.load();
+function Room(room_id, graphParts)
-await Desk.load();
+{
+    const rerender = van.state(0);
+    blocking.val;
 
-WorkMake({part:"p3", user:"u1", time:new Date().getTime(), data:"NEW!"});
+    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
+        }
+
+    )
+}
+
+function App()
+{
+    return Div.Plain(
+        DOM.button({onclick:PickHandle}, "Pick Directory"),
+        Object.entries(rooms.val).map(([room_id, graphParts])=>
+            Room(room_id, graphParts)
+        )
+    )
+}
+
+van.add(document.body, App);

block_core.ts

@@ -1,94 +0,0 @@
-export type Work = {data:string, user:string, time:number};
-export type Part = {name:string, time:number, work:Work[], need:Desk[], make:Desk[]};
-export type Need = [part:Part, time:number];
-export type DeskMode = "all" | "one";
-export type Desk = {name:string, need:Need[], make:Part[], mode:DeskMode, role:[]};
-
-const Part = (name:string):Part=>
-{
-    return {name, time:0, work:[], need:[], make:[]};
-}
-
-const Desk = (name:string, need:Need[], make:Part[], mode:DeskMode):Desk=>
-{
-    const obj:Desk = {name, need, make, mode, role:[]};
-    for(let i=0; i<need.length; i++)
-    {
-        const [part] = need[i];
-
-        part.need.push(obj);
-    }
-    for(let i=0; i<make.length; i++)
-    {
-        make[i].make.push(obj);
-    }
-    return obj;
-}
-
-const Work =(part:Part, data:string, time=Date.now())=>{
-    const work = {data, user:"", time};
-    if(time > part.time){
-        part.work.unshift(work);
-        part.time = time;
-    }
-    else
-    {
-        part.work.push(work);
-    }
-    part.need.forEach(Recompute);
-    part.make.forEach(Recompute);
-}
-
-const Recompute = (desk:Desk)=>{
-
-    let latestMake = -Infinity;
-    for(let i=0; i<desk.make.length; i++)
-    {
-        const {time} = desk.make[i];
-        if(time > latestMake)
-        {
-            latestMake = time;
-        } 
-    }
-
-    let latestNeed = -Infinity;
-    const dirtyNeed = [];
-    for(let i=0; i<desk.need.length; i++)
-    {
-        const [{time}] = desk.need[i];
-        if(time > latestNeed)
-        {
-            latestNeed = time;
-        } 
-        if(time < latestMake)
-        {
-            dirtyNeed.push(i);
-        }
-    }
-
-    const dirtyMake = []
-    for(let i=0; i<desk.make.length; i++)
-    {
-        const {time} = desk.make[i];
-        if(time > latestNeed)
-        {
-            dirtyMake.push(i);
-        } 
-    }
-
-    return [dirtyNeed, dirtyMake];
-}
-
-
-type User = {name:string};
-type Role = [name:string, users:[]]
-
-function BlockRole<Records extends Record<string, string>>(r:Records):{[K in keyof Records]: Role} {
-    const result = {};
-    for (const key in r) {
-        result[key] = [key, []];
-    }
-    return result;
-}
-
-export {Part, Desk, Work, Recompute, BlockRole};

block_graph.ts

@@ -1,4 +0,0 @@
-import * as Core from "./block_core.ts";
-
-const resp = await import("./block_role.ts");
-const roleTest = resp.default.r1;

block_role.ts

@@ -1,5 +0,0 @@
-import { BlockRole } from "./block_core.ts";
-
-export default BlockRole({
-    r1:"Developer"
-})

db.js

@@ -1,67 +0,0 @@
-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);
-    }
-}
-
-/** @import DBTypes from "./types.d.ts" */
-/** @type {DBTypes.Builder} */
-export default function(params)
-{
-    return {
-        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(){},
-    };
-}

db_desk.csv

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

db_part.csv

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

db_pass.csv

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

db_user.csv

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

db_work.csv

@@ -1,5 +0,0 @@
-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

@@ -0,0 +1,43 @@
+//@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,5 +1,8 @@
 {
-    "compilerOptions": {
+    "compilerOptions":
-        "checkJs": true
+    {
+        "checkJs": true,
+            "lib": ["deno.window", "DOM"],
+          "types": ["https://treetopflyer.github.io/gale/types.d.ts"]
     }
 }

graph/graph.js

@@ -0,0 +1,314 @@
+/** @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

@@ -0,0 +1,44 @@
+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

@@ -0,0 +1,57 @@
+<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

@@ -0,0 +1,43 @@
+//@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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

service-worker.js

@@ -0,0 +1,44 @@
+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

@@ -0,0 +1,109 @@
+// 📦 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

@@ -0,0 +1,64 @@
+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

@@ -1,16 +0,0 @@
-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>
-}