@gjsify/effect-platform 0.48.0

package/README.md

@@ -0,0 +1,103 @@
+# @gjsify/effect-platform
+
+[Effect](https://effect.website)'s platform services over GNOME. `effect/FileSystem` on
+`Gio.File`, `effect/Path` on GLib, `GError` mapped onto Effect's normalized platform errors, and a
+`/gtk` subpath that binds GObject lifetimes to Effect `Scope`s.
+
+Effect 4 runs on GJS unmodified. This package is not what makes it run; it is what makes it
+**GNOME**. See [ADR 0050](../../../docs/adr/0050-effect-platform-services-for-gnome.md) for why
+that is a platform package rather than a fourth renderer.
+
+```ts
+import { Effect } from 'effect'
+import * as FileSystem from 'effect/FileSystem'
+import { fileSystemLayer } from '@gjsify/effect-platform'
+
+const program = Effect.gen(function* () {
+  const fs = yield* FileSystem.FileSystem
+  return yield* fs.readDirectory('/etc')
+})
+
+await Effect.runPromise(Effect.provide(program, fileSystemLayer))
+```
+
+## Two entries, split by what they import
+
+| entry | provides | reaches |
+|---|---|---|
+| `@gjsify/effect-platform` | `fileSystemLayer`, `pathLayer`, `reasonOf`, `isIoError`, `toPlatformError`, `gioAsync` | GLib, GIO |
+| `@gjsify/effect-platform/gtk` | `widgetScope`, `windowScope`, `signalScope`, `runInScope`, `signalStream`, `propertyStream` | GTK, GObject |
+
+The root entry declares `gjsify.headless` and CI walks its import graph to hold it. A service
+layer that dragged in GTK could not be used from a daemon, a CLI or a test, which is where these
+services earn their keep.
+
+## What only this layer can do
+
+**Cancellation reaches GIO.** `Effect.callback` hands its register function an `AbortSignal`;
+every GIO async call takes a `Gio.Cancellable`. `gioAsync` wires the two, so interrupting a fiber
+stops the in-flight read rather than discarding its result. Nothing promise-based can offer that.
+
+**`effect/Path` is held against `node:path` operation by operation.** GLib has
+`g_path_get_basename` and `g_path_get_dirname`, and they are not `path.posix`: measured,
+`basename('')` is `.` where Node says `''`, and `dirname('a/b/')` is `a/b` where Node says `a`. The
+differential in `tests/integration/effect` found eleven such classes that hand-written expectations
+had all missed, which is why it exists.
+
+**A `GError` becomes a tag you can branch on.** Today every failing GIO call is a `GLib.Error`
+with a number whose meaning depends on its domain. Measured: `Gio.IOErrorEnum.NOT_FOUND` and
+`GLib.FileError.ISDIR` are both `1`, so a code read without its domain reports *is a directory* as
+*not found*. `reasonOf` refuses that, and a GIO code Effect has no tag for comes back `Unknown`
+rather than as a near miss.
+
+**A `Scope` closes with the widget.** `windowScope(window)` closes on `close-request` **or**
+`destroy`, whichever is first, and everything forked into it is interrupted. Two triggers, because
+`GtkWidget::destroy` is emitted from *dispose*: with the application holding a reference, which is
+always, `gtk_window_destroy()` emits `unrealize` and no `destroy`. The full measured matrix is in
+`src/gtk/scope.ts`.
+
+## Conformance
+
+Upstream authored `FileSystem.test-utils.ts` as a suite parameterised by a layer, so Node, Bun and
+Deno answer the same questions. [`tests/integration/effect`](../../../tests/integration/effect)
+ports it once and runs it twice: over `node:fs` and over this package's Gio layer. **Both pass all
+of it**, including the cases about the file cursor that nobody here would have thought to ask —
+seek backwards, `a+` with separate read and write positions, truncate under a live cursor. The
+per-run counts live in
+[`status/integration-coverage.md`](../../../status/integration-coverage.md), which is where a number
+can be re-measured instead of remembered.
+
+Three GIO semantics had to be corrected to get there, and each is recorded where it bites:
+
+- `g_file_replace*` is GIO's *atomic replace*: it writes a temporary file and moves it into place
+  on close, so the path still holds the old bytes until then. POSIX `w`/`w+` truncate in place, so
+  those flags open read-write and truncate instead.
+- A `GFileOutputStream` buffers where a descriptor does not, so every write flushes.
+- `g_file_copy_async`/`move_async` are typed with `GObject.Closure` parameters by `@girs`, which
+  is not constructible from GJS in any reasonable way, so the layer takes the synchronous call.
+  **`copy`, `copyFile` and `rename` are therefore the three methods here that are NOT
+  interruptible** — the call blocks the fiber for its whole duration, so an interrupt cannot be
+  delivered until after it returns. Everything else goes through `gioAsync`.
+
+## What it does not implement
+
+`realPath`, `link` and `glob` raise a **defect**, not a failure — GIO has no symlink-resolving
+canonicalizer, no hard-link call and no glob matcher. The distinction matters: `FileSystem.makeNoop`
+would answer `remove()` with a silent success and the rest with `NotFound`, which is the tag a
+genuinely missing file carries and which a `catchTag` would swallow. This package spells out the
+complete interface through `FileSystem.make` so a method added upstream cannot arrive as a silent
+default.
+
+## Cost
+
+Tree-shaking over Effect 4 works: you pay for what you import, and a GTK window using this layer
+lands in the same size class as comparable showcases that use no Effect at all. The figures, and
+which artifact each one came from, are in
+[ADR 0050](../../../docs/adr/0050-effect-platform-services-for-gnome.md) § Cost.
+
+## Peer dependency
+
+`effect` is a **peer** dependency, pinned to the exact RC rather than a range. A consumer's Effect
+and this layer's must be the same instance or the service keys do not match, and across prerelease
+tags a range does not guarantee that: `>=4.0.0-rc.112` admits `4.0.0-rc.113`, which is free to move
+a key. It relaxes to a caret the day 4.0.0 is stable.

package/lib/esm/_virtual/_rolldown/runtime.js

@@ -0,0 +1 @@
+var e=Object.defineProperty,__name=(t,n)=>e(t,`name`,{value:n,configurable:!0});export{__name};

package/lib/esm/errors.js

@@ -0,0 +1 @@
+import"./_virtual/_rolldown/runtime.js";import e from"gi://Gio?version=2.0";import t from"gi://GLib?version=2.0";import{PlatformError as n,SystemError as r}from"effect/PlatformError";const i=new Map([[e.IOErrorEnum.NOT_FOUND,`NotFound`],[e.IOErrorEnum.EXISTS,`AlreadyExists`],[e.IOErrorEnum.PERMISSION_DENIED,`PermissionDenied`],[e.IOErrorEnum.BUSY,`Busy`],[e.IOErrorEnum.TIMED_OUT,`TimedOut`],[e.IOErrorEnum.WOULD_BLOCK,`WouldBlock`],[e.IOErrorEnum.INVALID_DATA,`InvalidData`],[e.IOErrorEnum.CLOSED,`BadResource`],[e.IOErrorEnum.NOT_INITIALIZED,`BadResource`],[e.IOErrorEnum.NO_SPACE,`WriteZero`],[e.IOErrorEnum.PARTIAL_INPUT,`UnexpectedEof`]]),a=t.quark_to_string(e.io_error_quark()),isIoError=n=>n instanceof t.Error&&n.domain===e.io_error_quark(),reasonOf=e=>isIoError(e)?i.get(e.code)??`Unknown`:`Unknown`,toPlatformError=e=>new n(new r({_tag:reasonOf(e.error),module:e.module??`FileSystem`,method:e.method,pathOrDescriptor:e.pathOrDescriptor,description:describe(e.error),cause:e.error})),describe=e=>{if(e instanceof t.Error){let n=t.quark_to_string(e.domain)??String(e.domain);return n===a?e.message:`${n}(${e.code}): ${e.message}`}return e instanceof Error?e.message:String(e)};export{isIoError,reasonOf,toPlatformError};

package/lib/esm/file.js

@@ -0,0 +1 @@
+import"./_virtual/_rolldown/runtime.js";import{toPlatformError as e}from"./errors.js";import{gioAsync as t}from"./gio-async.js";import n from"gi://Gio?version=2.0";import r from"gi://GLib?version=2.0";import{Effect as i,Option as a}from"effect";import*as o from"effect/FileSystem";const s={r:{readable:!0,append:!1},"r+":{readable:!0,append:!1},w:{readable:!1,append:!1},"w+":{readable:!0,append:!1},wx:{readable:!1,append:!1},"wx+":{readable:!0,append:!1},a:{readable:!1,append:!0},"a+":{readable:!0,append:!0},ax:{readable:!1,append:!0},"ax+":{readable:!0,append:!0}},openOrCreate=(a,o,s,c)=>i.gen(function*(){yield*i.ignore(t({method:`open`,path:o,source:a,start:(e,t,i)=>e.create_async(n.FileCreateFlags.NONE,r.PRIORITY_DEFAULT,t,(e,t)=>i(t)),finish:(e,t)=>e.create_finish(t)}));let l=yield*t({method:`open`,path:o,source:a,start:(e,t,n)=>e.open_readwrite_async(r.PRIORITY_DEFAULT,t,(e,t)=>n(t)),finish:(e,t)=>e.open_readwrite_finish(t)});return c&&(yield*i.try({try:()=>l.truncate(0,null),catch:t=>e({method:`open`,pathOrDescriptor:o,error:t})})),{input:s.readable?l.get_input_stream():null,output:l.get_output_stream(),seekable:l,closable:l,plan:s}}),openStreams=(e,a)=>{let o=s[a],c=n.File.new_for_path(e),l=`open`,io=e=>({input:e.get_input_stream(),output:e.get_output_stream(),seekable:e,closable:e,plan:o});switch(a){case`r`:return i.map(t({method:l,path:e,source:c,start:(e,t,n)=>e.read_async(r.PRIORITY_DEFAULT,t,(e,t)=>n(t)),finish:(e,t)=>e.read_finish(t)}),e=>({input:e,output:null,seekable:e,closable:e,plan:o}));case`r+`:return i.map(t({method:l,path:e,source:c,start:(e,t,n)=>e.open_readwrite_async(r.PRIORITY_DEFAULT,t,(e,t)=>n(t)),finish:(e,t)=>e.open_readwrite_finish(t)}),io);case`w`:case`w+`:return openOrCreate(c,e,o,!0);case`wx`:case`ax`:return i.map(t({method:l,path:e,source:c,start:(e,t,i)=>e.create_async(n.FileCreateFlags.NONE,r.PRIORITY_DEFAULT,t,(e,t)=>i(t)),finish:(e,t)=>e.create_finish(t)}),e=>({input:null,output:e,seekable:e,closable:e,plan:o}));case`wx+`:case`ax+`:return i.map(t({method:l,path:e,source:c,start:(e,t,i)=>e.create_readwrite_async(n.FileCreateFlags.NONE,r.PRIORITY_DEFAULT,t,(e,t)=>i(t)),finish:(e,t)=>e.create_readwrite_finish(t)}),io);case`a`:return i.map(t({method:l,path:e,source:c,start:(e,t,i)=>e.append_to_async(n.FileCreateFlags.NONE,r.PRIORITY_DEFAULT,t,(e,t)=>i(t)),finish:(e,t)=>e.append_to_finish(t)}),e=>({input:null,output:e,seekable:e,closable:e,plan:o}));case`a+`:return openOrCreate(c,e,o,!1)}},makeFile=(s,c,l)=>{let u=0,fail=t=>n=>e({method:t,pathOrDescriptor:s,error:n,module:`FileSystem`}),seekTo=(e,t)=>i.try({try:()=>(c.seekable.seek(e,t,null),c.seekable.tell()),catch:fail(`seek`)}),readBytes=a=>{let o=c.input;return o===null?i.fail(e({method:`read`,pathOrDescriptor:s,module:`FileSystem`,error:r.Error.new_literal(n.io_error_quark(),n.IOErrorEnum.PERMISSION_DENIED,`file was not opened for reading`)})):i.gen(function*(){yield*seekTo(u,r.SeekType.SET);let e=(yield*t({method:`read`,path:s,source:o,start:(e,t,n)=>e.read_bytes_async(a,r.PRIORITY_DEFAULT,t,(e,t)=>n(t)),finish:(e,t)=>e.read_bytes_finish(t)})).toArray();return u+=e.length,e})},writeBytes=a=>{let o=c.output;return o===null?i.fail(e({method:`write`,pathOrDescriptor:s,module:`FileSystem`,error:r.Error.new_literal(n.io_error_quark(),n.IOErrorEnum.PERMISSION_DENIED,`file was not opened for writing`)})):i.gen(function*(){yield*seekTo(c.plan.append?0:u,c.plan.append?r.SeekType.END:r.SeekType.SET);let e=yield*t({method:`write`,path:s,source:o,start:(e,t,n)=>e.write_bytes_async(new r.Bytes(a),r.PRIORITY_DEFAULT,t,(e,t)=>n(t)),finish:(e,t)=>e.write_bytes_finish(t)});return yield*t({method:`write`,path:s,source:o,start:(e,t,n)=>e.flush_async(r.PRIORITY_DEFAULT,t,(e,t)=>n(t)),finish:(e,t)=>e.flush_finish(t)}),c.plan.append||(u+=e),e})};return{[o.FileTypeId]:o.FileTypeId,stat:l,seek:(e,t)=>i.sync(()=>{let n=t===`start`?Number(e):u+Number(e);return u=n<0?0:n,o.Size(u)}),sync:i.gen(function*(){let e=c.output;e!==null&&(yield*t({method:`sync`,path:s,source:e,start:(e,t,n)=>e.flush_async(r.PRIORITY_DEFAULT,t,(e,t)=>n(t)),finish:(e,t)=>e.flush_finish(t)}))}),read:e=>i.map(readBytes(e.length),t=>(e.set(t),o.Size(t.length))),readAlloc:e=>i.map(readBytes(Number(e)),e=>e.length===0?a.none():a.some(e)),truncate:e=>i.gen(function*(){let t=e===void 0?0:Number(e);yield*i.try({try:()=>c.seekable.truncate(t,null),catch:fail(`truncate`)}),u>t&&(u=t)}),write:e=>i.map(writeBytes(e),o.Size),writeAll:e=>i.gen(function*(){let t=0;for(;t<e.length;)t+=yield*writeBytes(e.subarray(t))})}},openFile=(e,t,n)=>i.acquireRelease(i.map(openStreams(e,t?.flag??`r`),t=>({streams:t,file:makeFile(e,t,n(e))})),({streams:e})=>i.ignore(i.try(()=>e.closable.close(null)))).pipe(i.map(({file:e})=>e));export{makeFile,openFile};

package/lib/esm/filesystem.js

@@ -0,0 +1 @@
+import"./_virtual/_rolldown/runtime.js";import{isIoError as e,toPlatformError as t}from"./errors.js";import{gioAsync as n}from"./gio-async.js";import{openFile as r}from"./file.js";import i from"gi://Gio?version=2.0";import a from"gi://GLib?version=2.0";import{badArgument as o}from"effect/PlatformError";import{Effect as s,Layer as c,Option as l,Result as u,Stream as d}from"effect";import*as f from"effect/FileSystem";import*as p from"effect/Queue";const m=[i.FILE_ATTRIBUTE_STANDARD_TYPE,i.FILE_ATTRIBUTE_STANDARD_SIZE,i.FILE_ATTRIBUTE_STANDARD_NAME,i.FILE_ATTRIBUTE_TIME_MODIFIED,i.FILE_ATTRIBUTE_TIME_ACCESS,i.FILE_ATTRIBUTE_TIME_CREATED,i.FILE_ATTRIBUTE_UNIX_MODE,i.FILE_ATTRIBUTE_UNIX_INODE,i.FILE_ATTRIBUTE_UNIX_NLINK,i.FILE_ATTRIBUTE_UNIX_UID,i.FILE_ATTRIBUTE_UNIX_GID,i.FILE_ATTRIBUTE_UNIX_DEVICE,i.FILE_ATTRIBUTE_UNIX_BLOCK_SIZE,i.FILE_ATTRIBUTE_UNIX_BLOCKS,i.FILE_ATTRIBUTE_ACCESS_CAN_READ,i.FILE_ATTRIBUTE_ACCESS_CAN_WRITE,i.FILE_ATTRIBUTE_ACCESS_CAN_EXECUTE].join(`,`),fileFor=e=>i.File.new_for_path(e),queryInfo=(e,t,r=!0)=>n({method:t,path:e,source:fileFor(e),start:(e,t,n)=>e.query_info_async(m,r?i.FileQueryInfoFlags.NONE:i.FileQueryInfoFlags.NOFOLLOW_SYMLINKS,a.PRIORITY_DEFAULT,t,(e,t)=>n(t)),finish:(e,t)=>e.query_info_finish(t)}),toDate=e=>e===null?l.none():l.some(new Date(e.to_unix()*1e3)),toNumber=e=>e===0?l.none():l.some(e),h=new Map([[i.FileType.REGULAR,`File`],[i.FileType.DIRECTORY,`Directory`],[i.FileType.SYMBOLIC_LINK,`SymbolicLink`],[i.FileType.SPECIAL,`Unknown`],[i.FileType.SHORTCUT,`Unknown`],[i.FileType.MOUNTABLE,`Unknown`],[i.FileType.UNKNOWN,`Unknown`]]),toInfo=e=>({type:h.get(e.get_file_type())??`Unknown`,mtime:toDate(e.get_modification_date_time()),atime:toDate(e.get_access_date_time()),birthtime:toDate(e.get_creation_date_time()),dev:e.get_attribute_uint32(i.FILE_ATTRIBUTE_UNIX_DEVICE),ino:toNumber(Number(e.get_attribute_uint64(i.FILE_ATTRIBUTE_UNIX_INODE))),mode:e.get_attribute_uint32(i.FILE_ATTRIBUTE_UNIX_MODE),nlink:toNumber(e.get_attribute_uint32(i.FILE_ATTRIBUTE_UNIX_NLINK)),uid:toNumber(e.get_attribute_uint32(i.FILE_ATTRIBUTE_UNIX_UID)),gid:toNumber(e.get_attribute_uint32(i.FILE_ATTRIBUTE_UNIX_GID)),rdev:l.none(),size:f.Size(e.get_size()),blksize:l.some(f.Size(e.get_attribute_uint32(i.FILE_ATTRIBUTE_UNIX_BLOCK_SIZE))),blocks:toNumber(Number(e.get_attribute_uint64(i.FILE_ATTRIBUTE_UNIX_BLOCKS)))}),readFile=e=>n({method:`readFile`,path:e,source:fileFor(e),start:(e,t,n)=>e.load_contents_async(t,(e,t)=>n(t)),finish:(e,t)=>{let[n,r]=e.load_contents_finish(t);if(!n)throw Error(`load_contents reported failure without raising`);return r}}),readDirectory=e=>s.scoped(readDirectoryScoped(e)),readDirectoryScoped=e=>s.gen(function*(){let t=yield*openEnumerator(e),r=[];for(;;){let i=yield*n({method:`readDirectory`,path:e,source:t,start:(e,t,n)=>e.next_files_async(64,a.PRIORITY_DEFAULT,t,(e,t)=>n(t)),finish:(e,t)=>e.next_files_finish(t)});if(i.length===0)break;for(let e of i)r.push(e.get_name())}return r}),openEnumerator=e=>s.acquireRelease(n({method:`readDirectory`,path:e,source:fileFor(e),start:(e,t,n)=>e.enumerate_children_async(i.FILE_ATTRIBUTE_STANDARD_NAME,i.FileQueryInfoFlags.NONE,a.PRIORITY_DEFAULT,t,(e,t)=>n(t)),finish:(e,t)=>e.enumerate_children_finish(t)}),e=>s.ignore(s.try(()=>e.close(null)))),dirnameOf=e=>a.path_get_dirname(e),makeTempDirectory=n=>s.try({try:()=>{let t=`${n?.prefix??`effect-platform-`}XXXXXX`;if(n?.directory===void 0)return a.Dir.make_tmp(t);for(let r=0;r<64;r++){let r=a.build_filenamev([n.directory,t.replace(`XXXXXX`,String(a.random_int()))]);try{return i.File.new_for_path(r).make_directory(null),r}catch(t){if(!e(t)||t.code!==i.IOErrorEnum.EXISTS)throw t}}throw Error(`no unused temporary directory name after 64 attempts`)},catch:e=>t({method:`makeTempDirectory`,error:e})}),makeTempFile=e=>s.flatMap(makeTempDirectory({directory:e?.directory,prefix:e?.prefix}),n=>s.try({try:()=>{let t=`${e?.prefix??`effect-platform-`}${a.random_int()}${e?.suffix??``}`,r=a.build_filenamev([n,t]);return i.File.new_for_path(r).create(i.FileCreateFlags.NONE,null).close(null),r},catch:e=>t({method:`makeTempFile`,error:e})})),remove=(e,t)=>s.gen(function*(){if(t?.recursive===!0){let n=yield*s.result(queryInfo(e,`remove`,!1));if(u.isSuccess(n)&&n.success.get_file_type()===i.FileType.DIRECTORY)for(let n of yield*readDirectory(e))yield*remove(a.build_filenamev([e,n]),t)}let r=yield*s.result(s.asVoid(n({method:`remove`,path:e,source:fileFor(e),start:(e,t,n)=>e.delete_async(a.PRIORITY_DEFAULT,t,(e,t)=>n(t)),finish:(e,t)=>e.delete_finish(t)})));if(u.isFailure(r)&&!(r.failure.reason._tag===`NotFound`&&(t?.force===!0||t?.recursive===!0)))return yield*s.fail(r.failure)}),copy=(e,n,r,c)=>s.gen(function*(){if(n===e||n.startsWith(`${e}${a.DIR_SEPARATOR_S}`))return yield*s.fail(o({module:`FileSystem`,method:c,description:`cannot copy a path into itself`}));if((yield*queryInfo(e,c,!1)).get_file_type()===i.FileType.DIRECTORY){yield*s.try({try:()=>{fileFor(n).make_directory_with_parents(null)},catch:e=>t({method:c,pathOrDescriptor:n,error:e})}).pipe(s.catchTag(`PlatformError`,e=>e.reason._tag===`AlreadyExists`?s.void:s.fail(e)));for(let t of yield*readDirectory(e))yield*copy(a.build_filenamev([e,t]),a.build_filenamev([n,t]),r,c);return}yield*copyOne(e,n,r,c)}),copyOne=(e,n,r,a)=>s.try({try:()=>{let t=i.FileCopyFlags.NONE;r?.overwrite===!0&&(t|=i.FileCopyFlags.OVERWRITE),r?.preserveTimestamps!==!0&&(t|=i.FileCopyFlags.TARGET_DEFAULT_MODIFIED_TIME),t|=i.FileCopyFlags.NOFOLLOW_SYMLINKS,fileFor(e).copy(fileFor(n),t,null,null)},catch:n=>t({method:a,pathOrDescriptor:e,error:n})}),watch=e=>d.callback(n=>s.gen(function*(){let r=yield*s.try({try:()=>fileFor(e).monitor(i.FileMonitorFlags.WATCH_MOVES,null),catch:n=>t({method:`watch`,pathOrDescriptor:e,error:n})}),a=r.connect(`changed`,(t,r,i,a)=>{let o=r.get_path()??e,s=g.get(a);s!==void 0&&p.offerUnsafe(n,s(o))});yield*s.addFinalizer(()=>s.sync(()=>{r.disconnect(a),r.cancel()}))})),g=new Map([[i.FileMonitorEvent.CREATED,e=>({_tag:`Create`,path:e})],[i.FileMonitorEvent.CHANGED,e=>({_tag:`Update`,path:e})],[i.FileMonitorEvent.ATTRIBUTE_CHANGED,e=>({_tag:`Update`,path:e})],[i.FileMonitorEvent.DELETED,e=>({_tag:`Remove`,path:e})],[i.FileMonitorEvent.MOVED_OUT,e=>({_tag:`Remove`,path:e})],[i.FileMonitorEvent.MOVED_IN,e=>({_tag:`Create`,path:e})]]),setAttribute=(e,t,r,o)=>s.gen(function*(){let s=yield*n({method:t,path:e,source:fileFor(e),start:(e,t,n)=>e.query_info_async(r,i.FileQueryInfoFlags.NONE,a.PRIORITY_DEFAULT,t,(e,t)=>n(t)),finish:(e,t)=>e.query_info_finish(t)});o(s),yield*n({method:t,path:e,source:fileFor(e),start:(e,t,n)=>e.set_attributes_async(s,i.FileQueryInfoFlags.NONE,a.PRIORITY_DEFAULT,t,(e,t)=>n(t)),finish:(e,t)=>e.set_attributes_finish(t)[1]})}),unimplemented=e=>s.die(Error(`@gjsify/effect-platform: FileSystem.${e} has no GIO equivalent`)),makeGioFileSystem=()=>f.make({access:(e,n)=>s.gen(function*(){let r=yield*queryInfo(e,`access`),denied=n=>s.fail(t({method:`access`,pathOrDescriptor:e,error:a.Error.new_literal(i.io_error_quark(),i.IOErrorEnum.PERMISSION_DENIED,`not ${n}`)}));if(n?.readable===!0&&!r.get_attribute_boolean(i.FILE_ATTRIBUTE_ACCESS_CAN_READ))return yield*denied(`readable`);if(n?.writable===!0&&!r.get_attribute_boolean(i.FILE_ATTRIBUTE_ACCESS_CAN_WRITE))return yield*denied(`writable`)}),stat:e=>s.map(queryInfo(e,`stat`),toInfo),readFile,readDirectory,readLink:e=>s.flatMap(queryInfo(e,`readLink`,!1),n=>{let r=n.get_symlink_target();return r===null?s.fail(t({method:`readLink`,pathOrDescriptor:e,error:a.Error.new_literal(i.io_error_quark(),i.IOErrorEnum.INVALID_ARGUMENT,`not a symbolic link`)})):s.succeed(r)}),realPath:()=>unimplemented(`realPath`),link:()=>unimplemented(`link`),glob:()=>unimplemented(`glob`),open:(e,t)=>r(e,t,e=>s.map(queryInfo(e,`stat`),toInfo)),makeDirectory:(e,r)=>r?.recursive===!0?s.try({try:()=>{fileFor(e).make_directory_with_parents(null)},catch:n=>t({method:`makeDirectory`,pathOrDescriptor:e,error:n})}):s.asVoid(n({method:`makeDirectory`,path:e,source:fileFor(e),start:(e,t,n)=>e.make_directory_async(a.PRIORITY_DEFAULT,t,(e,t)=>n(t)),finish:(e,t)=>e.make_directory_finish(t)})),remove:(e,t)=>remove(e,t),rename:(e,n)=>s.try({try:()=>{fileFor(e).move(fileFor(n),i.FileCopyFlags.OVERWRITE,null,null)},catch:n=>t({method:`rename`,pathOrDescriptor:e,error:n})}),copy:(e,t,n)=>copy(e,t,n,`copy`),copyFile:(e,t)=>copy(e,t,void 0,`copyFile`),symlink:(e,t)=>s.asVoid(n({method:`symlink`,path:t,source:fileFor(t),start:(t,n,r)=>t.make_symbolic_link_async(e,a.PRIORITY_DEFAULT,n,(e,t)=>r(t)),finish:(e,t)=>e.make_symbolic_link_finish(t)})),truncate:(e,t)=>s.scoped(s.flatMap(r(e,{flag:`r+`},e=>s.map(queryInfo(e,`stat`),toInfo)),e=>e.truncate(t))),chmod:(e,t)=>setAttribute(e,`chmod`,i.FILE_ATTRIBUTE_UNIX_MODE,e=>{e.set_attribute_uint32(i.FILE_ATTRIBUTE_UNIX_MODE,t)}),chown:(e,t,n)=>setAttribute(e,`chown`,i.FILE_ATTRIBUTE_UNIX_UID,e=>{e.set_attribute_uint32(i.FILE_ATTRIBUTE_UNIX_UID,t),e.set_attribute_uint32(i.FILE_ATTRIBUTE_UNIX_GID,n)}),utimes:(e,t,n)=>setAttribute(e,`utimes`,i.FILE_ATTRIBUTE_TIME_MODIFIED,e=>{let seconds=e=>BigInt(Math.floor(Number(e instanceof Date?e.getTime():e)/1e3));e.set_attribute_uint64(i.FILE_ATTRIBUTE_TIME_ACCESS,seconds(t)),e.set_attribute_uint64(i.FILE_ATTRIBUTE_TIME_MODIFIED,seconds(n))}),makeTempDirectory:e=>makeTempDirectory(e),makeTempDirectoryScoped:e=>s.acquireRelease(makeTempDirectory(e),e=>s.ignore(remove(e,{recursive:!0}))),makeTempFile:e=>makeTempFile(e),makeTempFileScoped:e=>s.acquireRelease(makeTempFile(e),e=>s.ignore(remove(dirnameOf(e),{recursive:!0}))),writeFile:(e,n,i)=>s.scoped(s.flatMap(r(e,{flag:i?.flag??`w`},e=>s.map(queryInfo(e,`stat`),toInfo)),e=>e.writeAll(n))).pipe(s.mapError(n=>n.reason._tag===`BadArgument`?n:t({method:`writeFile`,pathOrDescriptor:e,error:n.reason.cause??n}))),watch:e=>watch(e)}),_=c.sync(f.FileSystem)(makeGioFileSystem);export{_ as layer,makeGioFileSystem};

package/lib/esm/gio-async.js

@@ -0,0 +1 @@
+import"./_virtual/_rolldown/runtime.js";import{toPlatformError as e}from"./errors.js";import t from"gi://Gio?version=2.0";import{Effect as n}from"effect";const gioAsync=r=>n.callback((i,a)=>{let o=new t.Cancellable,onAbort=()=>o.cancel();a.addEventListener(`abort`,onAbort),r.start(r.source,o,t=>{if(a.removeEventListener(`abort`,onAbort),!o.is_cancelled())try{i(n.succeed(r.finish(r.source,t)))}catch(t){i(n.fail(e({method:r.method,pathOrDescriptor:r.path,error:t})))}})});export{gioAsync};

package/lib/esm/gtk/scope.js

@@ -0,0 +1 @@
+import"../_virtual/_rolldown/runtime.js";import{Effect as e,Exit as t,Scope as n}from"effect";const signalScope=(r,i)=>{let a=n.makeUnsafe(`sequential`),o=!1,s=[],disconnect=()=>{for(let e of s)r.disconnect(e);s=[]},close=()=>{if(o)return;o=!0,disconnect();let r=n.closeUnsafe(a,t.void);r!==void 0&&e.runFork(r)};return s=i.map(e=>r.connect(e,()=>(close(),!1))),{scope:a,close}},widgetScope=e=>signalScope(e,[`destroy`]),windowScope=e=>signalScope(e,[`close-request`,`destroy`]),runInScope=(t,n)=>e.runSync(e.forkIn(n,t));export{runInScope,signalScope,widgetScope,windowScope};

package/lib/esm/gtk/signal.js

@@ -0,0 +1 @@
+import"../_virtual/_rolldown/runtime.js";import{Effect as e,Stream as t}from"effect";import*as n from"effect/Queue";const signalStream=(r,i,a={})=>t.callback(t=>e.gen(function*(){let a=r.connect(i,(e,...r)=>{n.offerUnsafe(t,r)});yield*e.addFinalizer(()=>e.sync(()=>r.disconnect(a)))}),{bufferSize:a.bufferSize??16,strategy:a.strategy??`sliding`}),propertyStream=(e,n,r,i={})=>t.concat(t.sync(r),t.map(signalStream(e,`notify::${n}`,i),r));export{propertyStream,signalStream};

package/lib/esm/gtk.js

@@ -0,0 +1 @@
+import{runInScope as e,signalScope as t,widgetScope as n,windowScope as r}from"./gtk/scope.js";import{propertyStream as i,signalStream as a}from"./gtk/signal.js";export{i as propertyStream,e as runInScope,t as signalScope,a as signalStream,n as widgetScope,r as windowScope};

package/lib/esm/index.js

@@ -0,0 +1 @@
+import{isIoError as e,reasonOf as t,toPlatformError as n}from"./errors.js";import{gioAsync as r}from"./gio-async.js";import{layer as i,makeGioFileSystem as a}from"./filesystem.js";import{layer as o}from"./path.js";export{i as fileSystemLayer,r as gioAsync,e as isIoError,a as makeGioFileSystem,o as pathLayer,t as reasonOf,n as toPlatformError};

package/lib/esm/path.js

@@ -0,0 +1 @@
+import"./_virtual/_rolldown/runtime.js";import e from"gi://GLib?version=2.0";import{BadArgument as t}from"effect/PlatformError";import{Effect as n,Layer as r}from"effect";import{Path as i,TypeId as a}from"effect/Path";const o=e.DIR_SEPARATOR_S,isAbsolute=t=>e.path_is_absolute(t),join=(...t)=>{let n=t.filter(e=>e.length>0);return n.length===0?`.`:normalize(e.build_filenamev(n))},resolve=(...t)=>{let n=e.get_current_dir();for(let r of t)r.length!==0&&(n=isAbsolute(r)?r:e.build_filenamev([n,r]));return e.canonicalize_filename(n,null).replace(/^\/\/+/,o)},normalize=e=>{if(e.length===0)return`.`;let t=isAbsolute(e),n=e.length>1&&e.endsWith(o),r=[];for(let n of e.split(o))if(!(n===``||n===`.`)){if(n!==`..`){r.push(n);continue}r.length>0&&r[r.length-1]!==`..`?r.pop():t||r.push(`..`)}let i=r.join(o);return t?n&&i.length>0?`${o}${i}${o}`:`${o}${i}`:i.length===0?`.`:n?`${i}${o}`:i},basename=(e,t)=>{let n=e.replace(/\/+$/,``),r=n.slice(n.lastIndexOf(o)+1);return t!==void 0&&t!==r&&r.endsWith(t)?r.slice(0,r.length-t.length):r},dirname=e=>{if(e.length===0)return`.`;let t=isAbsolute(e),n=e.replace(/\/+$/,``);if(n.length===0)return o;let r=n.lastIndexOf(o);return r<0?`.`:r===0?o:t||r>0?n.slice(0,r):`.`},extname=e=>{let t=basename(e);if(t===`.`||t===`..`)return``;let n=t.lastIndexOf(`.`);return n<=0?``:t.slice(n)},parse=e=>{let t=isAbsolute(e)?o:``,n=basename(e),r=extname(e),i=e.replace(/\/+$/,``).lastIndexOf(o);return{root:t,dir:n.length===0?t===o?o:``:i<=0?t:e.slice(0,i),base:n,ext:r,name:r.length===0?n:n.slice(0,n.length-r.length)}},format=e=>{let t=e.base??`${e.name??``}${e.ext??``}`,n=e.dir??e.root??``;return n.length===0?t:n===e.root?`${n}${t}`:`${n}${o}${t}`},relative=(e,t)=>{let n=resolve(e).split(o).filter(Boolean),r=resolve(t).split(o).filter(Boolean),i=0;for(;i<n.length&&i<r.length&&n[i]===r[i];)i++;return[...Array(n.length-i).fill(`..`),...r.slice(i)].join(o)},fromFileUrl=r=>n.try({try:()=>e.filename_from_uri(r.href)[0],catch:e=>new t({module:`Path`,method:`fromFileUrl`,cause:e})}),toFileUrl=r=>n.try({try:()=>new URL(e.filename_to_uri(resolve(r),null)),catch:e=>new t({module:`Path`,method:`toFileUrl`,cause:e})}),s=r.succeed(i)({[a]:a,sep:o,basename,dirname,extname,format,fromFileUrl,isAbsolute,join,normalize,parse,relative,resolve,toFileUrl,toNamespacedPath:e=>e});export{s as layer};

package/lib/types/errors.d.ts

@@ -0,0 +1,23 @@
+import GLib from 'gi://GLib?version=2.0';
+import { PlatformError, type SystemErrorTag } from 'effect/PlatformError';
+/** `true` when this value is a `GLib.Error` raised by GIO itself. */
+export declare const isIoError: (error: unknown) => error is GLib.Error;
+/**
+ * The normalized reason for a caught value. Non-GIO errors — a `TypeError` from
+ * our own binding code, a `GLib.Error` from another domain — are `Unknown` rather
+ * than guessed at.
+ */
+export declare const reasonOf: (error: unknown) => SystemErrorTag;
+/**
+ * Wrap a caught GIO failure as the platform error `effect/FileSystem` declares.
+ *
+ * `module` is the Effect service that failed, not the GIO class, so a consumer
+ * reading `NotFound: FileSystem.readFile (/etc/nope)` cannot tell which layer
+ * produced it — which is the point.
+ */
+export declare const toPlatformError: (options: {
+    readonly method: string;
+    readonly pathOrDescriptor?: string | number;
+    readonly error: unknown;
+    readonly module?: string;
+}) => PlatformError;

package/lib/types/errors.spec.d.ts

@@ -0,0 +1,2 @@
+declare const _default: () => Promise<void>;
+export default _default;

package/lib/types/file.d.ts

@@ -0,0 +1,27 @@
+import Gio from 'gi://Gio?version=2.0';
+import { Effect } from 'effect';
+import type * as Scope from 'effect/Scope';
+import * as FileSystem from 'effect/FileSystem';
+import type { PlatformError } from 'effect/PlatformError';
+/** How a flag maps onto GIO: which streams it opens, and whether writes append. */
+export interface OpenPlan {
+    readonly readable: boolean;
+    /** Writes go to the end of the file regardless of the read position. */
+    readonly append: boolean;
+}
+/** The GIO streams behind one open file, plus what the flag asked for. */
+interface Streams {
+    readonly input: Gio.InputStream | null;
+    readonly output: Gio.OutputStream | null;
+    readonly seekable: Gio.Seekable;
+    readonly closable: Gio.IOStream | Gio.InputStream | Gio.OutputStream;
+    readonly plan: OpenPlan;
+}
+/** Build the `File` handle Effect's `open` promises. */
+export declare const makeFile: (path: string, streams: Streams, stat: Effect.Effect<FileSystem.File.Info, PlatformError>) => FileSystem.File;
+/** Open `path` and close its streams when the scope closes. */
+export declare const openFile: (path: string, options: {
+    readonly flag?: FileSystem.OpenFlag | undefined;
+    readonly mode?: number | undefined;
+} | undefined, stat: (path: string) => Effect.Effect<FileSystem.File.Info, PlatformError>) => Effect.Effect<FileSystem.File, PlatformError, Scope.Scope>;
+export {};

package/lib/types/filesystem.d.ts

@@ -0,0 +1,14 @@
+import { Layer } from 'effect';
+import * as FileSystem from 'effect/FileSystem';
+/**
+ * The Gio implementation.
+ *
+ * `FileSystem.make` and not `makeNoop`: `make` demands the COMPLETE interface, so a
+ * method added upstream cannot arrive here as a silent default. It derives `exists`
+ * from `access`, `readFileString` from `readFile`, and `stream`/`sink` from `open`,
+ * all four of which are implemented — so those derivations are correct here for
+ * free rather than inheriting a stub.
+ */
+export declare const makeGioFileSystem: () => FileSystem.FileSystem;
+/** Provide the Gio-backed `FileSystem` to a program. */
+export declare const layer: Layer.Layer<FileSystem.FileSystem>;

package/lib/types/filesystem.spec.d.ts

@@ -0,0 +1,2 @@
+declare const _default: () => Promise<void>;
+export default _default;

package/lib/types/gio-async.d.ts

@@ -0,0 +1,33 @@
+import Gio from 'gi://Gio?version=2.0';
+import type GObject from 'gi://GObject?version=2.0';
+import { Effect } from 'effect';
+import type { PlatformError } from 'effect/PlatformError';
+/**
+ * The one adapter every method below goes through: a GIO async pair
+ * (`x_async`/`x_finish`) as an interruptible Effect.
+ *
+ * `Effect.callback`'s `signal` is what makes it interruptible for real. Aborting it
+ * cancels the `Gio.Cancellable`, GIO completes the operation with
+ * `Gio.IOErrorEnum.CANCELLED`, and the `finish` call throws it — at which point
+ * nobody is listening, because `resume` after an interrupt is a no-op. So the
+ * catch is not swallowing an error, it is declining to report one for work whose
+ * requester is gone; anything else would be a defect raised in a dead fiber.
+ *
+ * `source` IS A PARAMETER, and it has to be. `g_task_is_valid(result, source)`
+ * checks that the object finishing an operation is the object that started it, and
+ * `Gio.File.new_for_path(p)` returns a NEW GFile every call — two files for the
+ * same path are not the same source. Measured on the first run of this showcase:
+ * a `finish` on a freshly constructed GFile logged
+ * `g_file_real_enumerate_children_finish: assertion 'g_task_is_valid (res, file)'
+ * failed`, returned `null`, and the failure surfaced one call later as
+ * `can't access property "next_files_async", r is null` — a null-dereference that
+ * names nothing about the actual mistake.
+ */
+export declare const gioAsync: <A, S extends GObject.Object>(options: {
+    readonly method: string;
+    readonly path: string;
+    /** The object the operation is started ON, and finished on. */
+    readonly source: S;
+    readonly start: (source: S, cancellable: Gio.Cancellable, done: (result: Gio.AsyncResult) => void) => void;
+    readonly finish: (source: S, result: Gio.AsyncResult) => A;
+}) => Effect.Effect<A, PlatformError>;

package/lib/types/gtk/scope.d.ts

@@ -0,0 +1,43 @@
+import type GObject from 'gi://GObject?version=2.0';
+import type Gtk from 'gi://Gtk?version=4.0';
+import { Effect, Scope } from 'effect';
+import type * as Fiber from 'effect/Fiber';
+/** A scope plus the means to close it early and stop listening. */
+export interface WidgetScope {
+    readonly scope: Scope.Closeable;
+    /** Close now and disconnect the triggers. Idempotent. */
+    readonly close: () => void;
+}
+/**
+ * A `Scope` closed by one or more signals on `source`, whichever fires first.
+ *
+ * Shared by the two functions below, and exported because a widget with a
+ * different end-of-life signal — a `Gtk.ListItem` being recycled, a page leaving
+ * an `Adw.NavigationView` — needs the same thing with a different name.
+ */
+export declare const signalScope: (source: GObject.Object, signals: ReadonlyArray<string>) => WidgetScope;
+/**
+ * A `Scope` closed when `widget` is DISPOSED — the boundary after which no fiber
+ * may touch it.
+ *
+ * Note what this does not do: `gtk_window_destroy()` does not emit `destroy` while
+ * a reference is held, so a window closed by the application keeps this scope open.
+ * For a window, use {@link windowScope}.
+ */
+export declare const widgetScope: (widget: Gtk.Widget) => WidgetScope;
+/**
+ * A `Scope` closed when `window` leaves the screen OR is disposed, whichever comes
+ * first — the lifetime an application means when it says "while this window is
+ * open".
+ */
+export declare const windowScope: (window: Gtk.Window) => WidgetScope;
+/**
+ * Start `effect` as a fiber owned by `scope`. Closing the scope interrupts it, and
+ * its finalizers run before the close completes.
+ *
+ * Returns the `Fiber` rather than a promise on purpose: the caller is a signal
+ * handler that must return NOW, and a promise there is a value GTK will
+ * misinterpret. If you need the outcome, that is `fiber.addObserver(exit => …)`,
+ * which is synchronous and one line.
+ */
+export declare const runInScope: <A, E>(scope: Scope.Scope, effect: Effect.Effect<A, E, never>) => Fiber.Fiber<A, E>;

package/lib/types/gtk/signal.d.ts

@@ -0,0 +1,58 @@
+import type GObject from 'gi://GObject?version=2.0';
+import { Stream } from 'effect';
+export interface SignalStreamOptions {
+    /** Queue depth. Small on purpose: a UI signal's backlog has no value. */
+    readonly bufferSize?: number;
+    /**
+     * What a full buffer does. `'sliding'` drops the oldest; `'suspend'` blocks the
+     * emitter, which for a main-loop signal means the window stops drawing.
+     *
+     * `'suspend'` is offered rather than forbidden because the type is `Queue`'s own
+     * and a non-main-loop `GObject` — a worker's `Gio.Task`, an `EventBus` — can
+     * legitimately want it. For anything GTK emits it is the wrong answer.
+     */
+    readonly strategy?: 'sliding' | 'suspend';
+}
+/**
+ * Every emission of `signalName` on `source`, as a `Stream` of the handler's
+ * arguments (the emitting object itself is dropped, as it is always `source`).
+ *
+ * The handler returns nothing, so this is only correct for signals whose return
+ * value GTK ignores. A signal with a meaningful return — `key-pressed`,
+ * `close-request` — must be handled synchronously; see `runInScope` in `scope.ts`
+ * for the split.
+ *
+ * The connection is a resource: `Effect.addFinalizer` disconnects it when the
+ * stream's scope closes, so a stream held by a widget scope stops listening the
+ * moment the widget is destroyed.
+ *
+ * SUBSCRIBING IS ASYNCHRONOUS, and nothing buffers an emission that beats it. The
+ * `connect()` below runs when the stream is first PULLED, not when it is
+ * constructed and not when a fiber running it is forked — so an emission between
+ * those two moments is simply not seen. In an application this is invisible,
+ * because the subscription is set up in a constructor and the first emission comes
+ * from a user; it is visible the moment a test emits programmatically, and the
+ * showcase's probe has to sleep before it emits for that reason.
+ */
+export declare const signalStream: <A extends ReadonlyArray<unknown> = ReadonlyArray<unknown>>(source: GObject.Object, signalName: string, options?: SignalStreamOptions) => Stream.Stream<A>;
+/**
+ * The common special case: a GObject property, as a stream of its values, starting
+ * with the value it has now.
+ *
+ * Starting with the current value is what makes this usable as a source of truth
+ * rather than a change log — a consumer subscribing after the property was already
+ * set otherwise renders an empty view until the user types again. It does NOT close
+ * the subscription gap above: `Stream.concat` reads the seed before the second
+ * stream is pulled, so a change landing in between is still missed. What it fixes is
+ * the steady state, not the race.
+ *
+ * `read` IS EXPLICIT, and both reasons are worth stating. `GObject.Object.get_property`
+ * is the GIR method, which takes a name AND a `GObject.Value` to fill — a
+ * one-argument call throws `At least 2 arguments required, but only 1 passed`,
+ * measured here on the showcase's first probe run. And even given a working
+ * reflective read, the GObject name and the JS name differ (`icon-name` is
+ * `iconName`), so a helper that mapped between them would be guessing at a
+ * convention that has exceptions. Passing the getter costs one closure and is
+ * typed.
+ */
+export declare const propertyStream: <T>(source: GObject.Object, property: string, read: () => T, options?: SignalStreamOptions) => Stream.Stream<T>;

package/lib/types/gtk.d.ts

@@ -0,0 +1,2 @@
+export { runInScope, signalScope, widgetScope, windowScope, type WidgetScope } from './gtk/scope.js';
+export { propertyStream, signalStream, type SignalStreamOptions } from './gtk/signal.js';

package/lib/types/index.d.ts

@@ -0,0 +1,4 @@
+export { isIoError, reasonOf, toPlatformError } from './errors.js';
+export { gioAsync } from './gio-async.js';
+export { layer as fileSystemLayer, makeGioFileSystem } from './filesystem.js';
+export { layer as pathLayer } from './path.js';

package/lib/types/path.d.ts

@@ -0,0 +1,4 @@
+import { Layer } from 'effect';
+import { Path } from 'effect/Path';
+/** Provide the GLib-backed `Path` to a program. */
+export declare const layer: Layer.Layer<Path>;

package/lib/types/path.spec.d.ts

@@ -0,0 +1,2 @@
+declare const _default: () => Promise<void>;
+export default _default;

package/package.json

@@ -0,0 +1,89 @@
+{
+    "name": "@gjsify/effect-platform",
+    "version": "0.48.0",
+    "description": "Effect's platform services over GNOME: effect/FileSystem on Gio.File with cancellation that reaches GIO, effect/Path on GLib, GError mapped onto Effect's normalized platform errors, and a /gtk subpath binding GObject lifetimes to Effect Scopes",
+    "keywords": [
+        "effect",
+        "gjs",
+        "gnome",
+        "gio",
+        "glib",
+        "gtk",
+        "filesystem",
+        "platform"
+    ],
+    "type": "module",
+    "main": "lib/esm/index.js",
+    "module": "lib/esm/index.js",
+    "types": "lib/types/index.d.ts",
+    "exports": {
+        ".": {
+            "types": "./lib/types/index.d.ts",
+            "default": "./lib/esm/index.js"
+        },
+        "./gtk": {
+            "types": "./lib/types/gtk.d.ts",
+            "default": "./lib/esm/gtk.js"
+        },
+        "./package.json": "./package.json"
+    },
+    "sideEffects": false,
+    "files": [
+        "lib"
+    ],
+    "scripts": {
+        "clear": "gjsify clear lib tmp tsconfig.tsbuildinfo test.gjs.mjs",
+        "check": "gjsify tsc --noEmit",
+        "build": "gjsify run build:gjsify && gjsify run build:types",
+        "build:gjsify": "gjsify build --library 'src/**/*.{ts,js}' --exclude 'src/**/*.spec.{mts,ts}' 'src/test.{mts,ts}'",
+        "build:types": "gjsify tsc",
+        "build:test": "gjsify run build:test:gjs",
+        "build:test:gjs": "gjsify build src/test.mts --app gjs --outfile test.gjs.mjs",
+        "test": "gjsify run build:gjsify && gjsify run build:test && gjsify run test:gjs",
+        "test:gjs": "gjsify run test.gjs.mjs"
+    },
+    "gjsify": {
+        "runtimes": {
+            "gjs": "polyfill",
+            "node": "none",
+            "browser": "none",
+            "nativescript": "none"
+        },
+        "tier": 3,
+        "headless": [
+            "Gdk",
+            "GdkPixbuf",
+            "Gsk",
+            "Gtk",
+            "Adw"
+        ]
+    },
+    "dependencies": {
+        "@girs/gio-2.0": "4.6.0",
+        "@girs/gjs": "4.6.0",
+        "@girs/glib-2.0": "4.6.0",
+        "@girs/gobject-2.0": "4.6.0",
+        "@girs/gtk-4.0": "4.6.0"
+    },
+    "peerDependencies": {
+        "effect": "4.0.0-rc.112"
+    },
+    "devDependencies": {
+        "@gjsify/cli": "^0.48.0",
+        "@gjsify/unit": "^0.48.0",
+        "@types/node": "^25.9.2",
+        "effect": "4.0.0-rc.112",
+        "typescript": "^6.0.3"
+    },
+    "author": "Pascal Garber <pascal@artandcode.studio>",
+    "license": "MIT",
+    "repository": {
+        "type": "git",
+        "url": "git+https://github.com/gjsify/gjsify.git",
+        "directory": "packages/framework/effect-platform"
+    },
+    "bugs": {
+        "url": "https://github.com/gjsify/gjsify/issues"
+    },
+    "homepage": "https://github.com/gjsify/gjsify/tree/main/packages/framework/effect-platform#readme"
+}