feat(domain): R4.3a FileBytes sink and the bytes entries of the wasm facade

FileBytes gathers a file chunk by chunk in linear memory (capacity reserved from the
announced size, refused above the PDF cap); SheetHandle.import_pdf_bytes and
restore_copy_bytes consume it, so the worker streams file.stream() and the file lives
once, never as a JavaScript ArrayBuffer nor as a JSON-wrapped string. restore_copy:
strict UTF-8, one BOM, the OD-3 budget, draft.restore's kinds. Node: same envelopes as
import_pdf on the 51 O8 cases; rescue-copy parity with draft.restore.
This commit is contained in:
bchanot committed 2026-10-18 17:45:39 +02:00
1 parent f41dd59b2c
commit 52471dbbc0
5 files changed
+166 -12

No files matched your search

+21
View File
@@ -77,6 +77,27 @@ pub fn import_pdf(sheet: &LoadedSheet, bytes: &[u8]) -> String {
render(outcome)
}
/// A rescue copy picked as a file (R4.3, plan §B.1.5 item 4), read as the bytes the worker
/// streamed: strict UTF-8 as `TextDecoder('utf-8', { fatal: true })` read it, one leading
/// BOM dropped, then `draft.restore` with no archive, including its OD-3 value budget. The
/// kinds are `draft.restore`'s; a text that is not UTF-8 is `invalid`, as the application
/// already called it (`error_invalid_copy`). Takes the bytes by value: the copy lives once.
pub fn restore_copy(sheet: &LoadedSheet, bytes: Vec<u8>) -> String {
use crate::domain::session::restore_draft;
use crate::ops::{over_value_budget, restore_failure};
let outcome = String::from_utf8(bytes)
.map_err(|_| Failure::new("invalid", "the copy is not valid UTF-8"))
.and_then(|text| {
let text = text.strip_prefix('\u{FEFF}').map_or(text.as_str(), |t| t);
if over_value_budget(text) {
return Err(Failure::new("invalid", "json value budget exceeded"));
}
restore_draft(sheet, text, None).map_err(restore_failure)
})
.and_then(|restore| to_value(&restore));
render(outcome)
}
fn unknown(op: &str) -> Failure {
Failure::new("unknown_op", format!("no operation named {op}"))
}
+12 -7
View File
@@ -323,16 +323,21 @@ fn draft_restore(sheet: &LoadedSheet, input: &str) -> Outcome {
return Err(Failure::new("invalid", "json value budget exceeded"));
}
session::restore_draft(sheet, &input.draft, input.archive.as_deref())
.map_err(|failure| match failure {
RestoreFailure::UnsupportedVersion(found) => versioned("unsupported_version", found),
RestoreFailure::LoneSurrogate(detail) => Failure::new("lone_surrogate", detail),
RestoreFailure::Invalid(detail) => Failure::new("invalid", detail),
RestoreFailure::Rebase(detail) => Failure::new("rebase_failed", detail),
})
.map_err(restore_failure)
.and_then(|restore| to_value(&restore))
}
fn over_value_budget(text: &str) -> bool {
/// The closed kinds of a draft restore failure, shared with the rescue copy read as bytes.
pub(crate) fn restore_failure(failure: RestoreFailure) -> Failure {
match failure {
RestoreFailure::UnsupportedVersion(found) => versioned("unsupported_version", found),
RestoreFailure::LoneSurrogate(detail) => Failure::new("lone_surrogate", detail),
RestoreFailure::Invalid(detail) => Failure::new("invalid", detail),
RestoreFailure::Rebase(detail) => Failure::new("rebase_failed", detail),
}
}
pub(crate) fn over_value_budget(text: &str) -> bool {
prescan(text.as_bytes()).values > MAX_JSON_VALUES
}
+59
View File
@@ -4,6 +4,7 @@
//! the application behind the sheet and import paths (`packages/core-wasm/src/runtime.ts`).
use faunosteo_core::domain::sheet::LoadedSheet;
use faunosteo_core::pdf::read::MAX_PDF_BYTES;
use wasm_bindgen::prelude::{JsError, wasm_bindgen};
/// Version of the core compiled into this module.
@@ -48,6 +49,64 @@ impl SheetHandle {
pub fn import_pdf(&self, bytes: &[u8]) -> String {
faunosteo_core::facade::import_pdf(&self.sheet, bytes)
}
/// The same import on bytes streamed into the module's memory (`FileBytes`), consumed:
/// the file lives once, in linear memory, never as a JavaScript ArrayBuffer (R4.3a).
pub fn import_pdf_bytes(&self, bytes: FileBytes) -> String {
faunosteo_core::facade::import_pdf(&self.sheet, &bytes.data)
}
/// A rescue copy streamed into the module's memory, consumed: strict UTF-8, one BOM,
/// the value budget, then `draft.restore` without an archive (R4.3a).
pub fn restore_copy_bytes(&self, bytes: FileBytes) -> String {
faunosteo_core::facade::restore_copy(&self.sheet, bytes.data)
}
}
/// A file's bytes gathered chunk by chunk in the module's memory (R4.3a): the worker reads
/// `file.stream()` and pushes each chunk, so the only whole copy of the file is this one.
/// The capacity is reserved up front from the file size the worker announces, capped at the
/// PDF limit; a push past the announced size is refused (`false`) and the bytes dropped.
#[wasm_bindgen]
pub struct FileBytes {
data: Vec<u8>,
expected: usize,
}
#[wasm_bindgen]
impl FileBytes {
/// `expected` is the file size; above the PDF cap nothing is reserved and every push
/// is refused, so the caller's own size check stays the only one that reads a file.
#[wasm_bindgen(constructor)]
pub fn new(expected: u32) -> FileBytes {
let expected = expected as usize;
let expected = if expected > MAX_PDF_BYTES {
0
} else {
expected
};
FileBytes {
data: Vec::with_capacity(expected),
expected,
}
}
/// Appends a chunk; `false` (nothing appended) once the announced size would be passed.
pub fn push(&mut self, chunk: &[u8]) -> bool {
if self.data.len().saturating_add(chunk.len()) > self.expected {
return false;
}
self.data.extend_from_slice(chunk);
true
}
pub fn len(&self) -> u32 {
u32::try_from(self.data.len()).unwrap_or(u32::MAX)
}
pub fn is_empty(&self) -> bool {
self.data.is_empty()
}
}
/// R4.2e proof: the import with the OD-3 value cap off, so that a token-dense document runs