Taking the lock on Script Grants.lock blocked until the holder let go,
so another process that stalled while holding it stopped listing,
loading, keeping and revoking grants for good. The lock is now tried 20
times, 50 ms apart, and then fails with TimedOut: a change is not made
and a read gives no grants rather than reading without the lock.
`rename` moved the write path of open File objects but left the path they
were read from at the old name. When new code then withdrew the kept grant
for the folder, a grant the run still held for the old path let the object
go on giving the file's bytes. The read path now moves with the write path.
Keeping a second grant with Always marked all the code the run had
evaluated as recorded, so the run's end skipped the grants kept before
it, and they kept the code list from when they were kept. The next run
that evaluated that code withdrew them. Keeping a grant now writes the
current code list into the grants the run kept before it as well.
When a run evaluated code that withdrew a kept grant, a File opened under that grant still gave the bytes it held to read, readln and readch, and seek to the end showed its length. Those calls now give Script file access denied and set error, and eof is true. docs/mcp.md says so.
Two processes that changed Script Grants.json at once both wrote Script Grants.json.part, so one could overwrite the other's file or fail on it. Each write now goes to a new file named for its process and write, passing over a name an earlier write left behind, and only that file is removed when the write fails. Changes hold a lock on Script Grants.lock beside the grants file and are not made when it cannot be taken; reads take it when they can.
The settings folder is closed to scripts except for a script's own folder inside it. The test runs a script from settings/Scripts, reads a file beside it and is refused a file elsewhere in the settings folder.
copy read the source's real path as it was when looked up, so a file replaced by a link before the read could copy a file from outside the script's places, and a link given as the source that was pointed elsewhere copied the old target. copy now reads the path as given through the same checks open uses and refuses the copy with Script file access denied when the path no longer leads to the file it was looked up as.
rename named only the new path in written, so a run that renamed a file an earlier run wrote did not name the path it emptied. It now names both, as remove names the path it deletes.
- A command a script runs reads only where the script may, also in a run the person started; only
reads of the app's own folders inside the command are exempt.
- Always and script.grants.revoke leave a grants file they cannot read as it is, and fail.
- script.grants names a path outside the automation read roots by its file name alone.
- copy reads the source once, within the 8 MiB limit, writes those bytes, and gives the copy the
source's permissions.
- write joins its values as UTF-16 before making them text, so a surrogate pair split between two
values is one character.
A script run from a file directly in the settings folder could read every
file in that folder, Script Grants.json included, because its own folder
was left open inside the fence. Only folders below the settings folder
stay open now, and a script in the settings folder itself reads only its
own file there.
A script's File and Folder objects now open files for writing, appending
and editing, and copy, rename, remove and create files and folders. A
script reads and writes its run's temporary folder (Folder.temp) and its
own data folder (Folder.userData), kept between runs for a script run
from a file and inside Folder.temp for a script given as text. It reads
its own folder, and reaches other places only through File.openDialog,
File.saveDialog, Folder.selectDialog and the objects' openDlg, saveDlg and
selectDlg.
- A file dialog asks first. The person picks the file or folder with
Choose..., then allows it once or, for a script run from a file, always.
A kept grant is bound to the script's path, the SHA-256 of its text and
every source the run evaluated. It is withdrawn when a later run of the
script evaluates other code, including code an earlier run left in the
same named engine. It stays on the real path that was granted, so a
link put in that place later does not carry it elsewhere.
- A dialog's filter is a string of file types or a function that is
called with each file picked; multiSelect gives an array of the files
picked, at most 2,048, and the dialog says when more were left out.
- A folder's selectDlg opens the host's folder dialog in that folder,
also where the host shows file dialogs in line. Enter in the file
dialog denies, unless it goes to the focused Choose... button.
script.grants.revoke is refused with the busy error while a script
runs, as the run keeps the grants it started with.
- The paths a file dialog allows come only from the host's file dialog:
ui.dialog.set cannot set them. Only the person at the keyboard allows
access; Allow Once and Always Allow sent by automation are refused. The
dialog describes the access the run asked for, whatever its fields say.
- No grant reaches the settings folder, also when the script's own folder
holds it.
- A file left open is not written through a link put in place of its
folder since it was opened, and Folder.userData is null when the data
folder or the script's folder in it is a link.
- copy onto another link to the same file (a hard link) leaves the file's
bytes as they are, after the source's open objects have written what
they hold. Files are compared by identity (device and inode on Unix,
volume and file index on Windows).
- Folder.temp and Folder.userData check each folder they make against the
automation write roots first, and Folder.create() makes nothing when a
missing folder above the target is outside the places the script may
write.
- An open file holds at most 8 MiB, a run writes at most 32 MiB and keeps
at most 256 files open, and the files a run left open are written in
the order they were opened. Setting length and copying a file count the
bytes every open object of that file takes, and write checks the joined
text against the limit while joining it. The report names at most 4,096
written files and sets writtenMore when there were more.
- Errors a script sees are translated in every complete message catalog.
A missing file below a folder link whose target does not exist got
"does not exist", while one below a link to an existing outside folder
was refused, so a script could tell whether the folder a link leads to
exists. A missing path is now refused when the nearest entry above it
that exists is a link that leads to nothing.
A `File` or `Folder` for a missing path got "does not exist" even when
the path led outside the script's folder, through a folder link or, on a
file system where case matters, through a folder whose name differs from
the script's folder only in case, while an existing file there was
refused. A missing path is now refused unless the nearest folder above
it that exists lies inside a granted folder.
- `File.encode` and `Folder.encode` leave `/` unescaped, as the File
object reference lists it among the characters kept
(https://extendscript.docsforadobe.dev/file-system-access/file-object/).
- `exists` is true for a `File` only when the path names something
other than a folder, and for a `Folder` only when it names a folder.
- Fields of the records the app returns are read as own properties, so
a property a script puts on `Object.prototype` does not turn a
successful `open` into a failure.
- `File.encode`, `File.decode`, `File.isEncodingAvailable` and the
`Folder` locations count as file calls and charge the host-call limit.
- On the web the locations are `null` and `File.tempName` names a file
at the root, without asking the platform for a temporary folder.
Outside Windows, `\\host\s\x.txt`, `\\?\C:\x.txt` and `\\.\pipe\x` are
relative file names in the script's folder, so `exists`, `open` and
`getFiles` look them up. The test now expects no lookups for them on
Windows only, and on macOS and Linux checks `//host/s/x.txt`, an absolute
path outside the folder, alone. The returned values are the same on every
platform.
Scripts get the File and Folder classes as built-ins of the script
engine. A script run from a file can test whether files exist, read
their properties, list folders with getFiles (a mask or a function),
and open files to read them with read, readln, readch, seek and tell.
- Reads stay inside the script's folder and, when automation read
roots are set, inside them too. A script given as text reads no
files. Network and device paths, and paths outside the folder by
their names, are refused before anything is looked up. Links and
junctions that lead out are refused, and getFiles leaves them out.
- The encoding comes from the byte order mark, then the encoding the
script set, then UTF-8 when the bytes are valid, then CP1252.
- Limits: 8 MiB a file, 32 MiB a run, 256 files open at once, 2,048
getFiles entries and 65,536 names looked at, and paths of at most
32,767 characters.
- Writing, the file dialogs and execute are not available yet: they
return false or null and set error.
The report's hostCallCounts gains fileCalls and fileExecutes.
Docs: docs/mcp.md, docs/target-app-parity.md.