Preprint
Article

This version is not peer-reviewed.

Architectural Trade-Offs in a Real-Time AI Transcription Assistant: An Evidence-Guided Case Study

Submitted:

15 November 2026

Posted:

17 November 2026

You are already at the latest version

Abstract
Background: Real-time AI information systems increasingly combine local speech processing, remote language-model inference, interactive state, and persistence within one workflow. The resulting engineering problem is partly architectural: reliability and maintainability depend on how computational, protocol, and state boundaries are defined. Objective: I examine how those boundaries are implemented in a real-time AI transcription assistant and identify trade-offs and failure modes that are not visible in a component-level architecture alone. Methods: I performed a single-case, artifact-grounded architectural study using an architecture specification, a code-level walkthrough, and execution-oriented implementation traces. I reconstructed dependencies, traced representative workflows, examined model and state lifecycles, and inspected error and persistence semantics. Results: The case implements two runtime processes and a three-layer responsibility structure, process-local lazy speech-model initialization, a voice-activity-driven utterance state machine, cloud LLM inference through synchronous and streaming interfaces, and JSON-framed server-sent events. The analysis identifies four recurring architectural tensions: process separation versus duplicated model state; permissive contracts versus semantic validation; stream framing versus end-to-end error semantics; and availability-oriented persistence versus audit completeness. Conclusion: The study contributes an evidence-guided architectural account and a set of case-derived, testable propositions that clarify how boundary decisions shape real-time AI information systems.
Keywords: 
;  ;  ;  ;  ;  ;  

I. Introduction

Modern information systems increasingly place heterogeneous AI capabilities inside a single user interaction. A speech recognizer may run locally because audio is continuous and relatively high-rate, while a large language model (LLM) may run remotely because its inference service is externally hosted. At the same time, the user interface must maintain interactive state, streaming output must remain protocol-correct, and interaction records may need persistence. The engineering difficulty is therefore not reducible to choosing a capable model. It is the coordination of boundaries between components with different latency, state, failure, and resource assumptions.
This problem is closely related to machine-learning technical debt. Sculley et al. identified boundary erosion, entanglement, undeclared dependencies, and configuration problems as recurring sources of long-term risk in ML systems [1]. Later work has catalogued reusable software-engineering patterns for ML applications [4] and mapped architectural components used in MLOps systems [5,6]. These studies establish the value of explicit architectural decomposition, but a practical implementation still has to decide where state lives, where failures become visible, and which boundaries are synchronous, streamed, or best effort.
I study these questions through an implemented AI transcription assistant. The case supports audio or text transcription, summarization, correction and formatting, suggestion chat, a Live Assistant, and session history. Its runtime combines a Gradio presentation process, a FastAPI backend, local faster-whisper speech-to-text, AWS Bedrock LLM integration, WebRTC-based voice activity detection, server-sent events (SSE), and object-storage session persistence. The supplied implementation artifacts describe not only the nominal architecture but also concrete execution paths and known defects, making the case suitable for an implementation-grounded architectural investigation.
The study addresses three research questions: RQ1: How are presentation, API, service, AI-runtime, and persistence responsibilities separated? RQ2: What trade-offs arise at the boundaries between local speech processing, cloud LLM inference, real-time state handling, and persistence? RQ3: Which reliability and maintainability properties become visible when the implementation is traced beyond the high-level architecture?
I make four contributions. First, I reconstruct the runtime architecture and relate process boundaries to logical responsibility boundaries. Second, I provide trace-based findings for synchronous and streaming workflows, including state and lifecycle behavior. Third, I characterize architectural trade-offs and failure semantics using evidence from the implementation rather than inferred maturity labels. Fourth, I derive case-based propositions and an evaluation agenda that identifies the measurements required to test the most consequential architectural assumptions.

III. Methods

A. Case and Evidence Sources

I conducted a single-case, artifact-grounded architectural study. The case is the implemented AI transcription assistant and its documented runtime. The unit of analysis is a boundary or execution path that coordinates two or more responsibilities, rather than an isolated source-code statement. Three author-supplied artifacts formed the evidence base: an architecture and implementation framework, a code-level walkthrough, and an architecture-and-execution specification. The first describes intended structure; the second traces imports, functions, state, and defects; the third relates modules to runtime interactions and representative end-to-end flows.
I distinguish evidence provenance explicitly. A Direct finding follows from an implementation statement or documented execution trace. A Derived finding connects two or more direct observations to identify an architectural consequence. An External claim is supported by literature or a technical specification. This classification is important because several tempting claims, such as latency superiority or scalability, are not measurable from the supplied artifacts alone.
Table 1 summarizes the three evidence sources and their role in the architectural analysis.

B. Analytical Procedure

I used six analysis passes. First, I reconstructed the dependency graph and runtime processes. Second, I mapped feature paths to API endpoints and service modules. Third, I traced two representative executions: Transcribe-to-Summarise and the Live Assistant. Fourth, I examined lifecycle and state ownership for the speech model, session identifier, VAD buffer, and streamed reply. Fifth, I performed failure-boundary analysis, recording where errors are propagated, converted to protocol events, or silently suppressed. Sixth, I compared the resulting observations with the software-engineering and MLOps literature and converted repeated mechanisms into case-derived propositions.
The analysis is intentionally qualitative rather than score-based. I use six evaluation dimensions: responsibility separation, contract consistency, resource ownership, real-time state control, streaming integrity, and persistence/operational resilience. Each dimension is supported by observable implementation behavior and paired with a residual uncertainty. This prevents a qualitative architecture audit from being converted into an unsupported numerical maturity score.
Table 2 connects each research question to the trace-based evidence used to address it.

C. Validity and Study Boundaries

The main construct threat is documentation drift: architecture descriptions may omit implementation behavior. I mitigate this by accepting a capability as present only when it is supported by implementation-level evidence. Internal validity is limited because I did not independently reproduce the deployment or run a controlled workload; therefore, runtime performance statements are excluded. External validity is also limited because a single system cannot establish statistical generalization. The result is intended as analytic generalization: the case exposes mechanisms and trade-offs that can be tested elsewhere, rather than claiming that all similar systems behave identically.
A further concern is disclosure bias. Some deployment identifiers and configuration names are intentionally abstracted from the manuscript. This reduces reproducibility of the exact infrastructure configuration, but it does not prevent the logical architecture and execution mechanisms from being described. No human-subject experiment, user survey, or animal study was conducted as part of this analysis.

D. AI-Assisted Tools Disclosure

During preparation of this preprint revision, an AI language model was used to assist with editorial review and document preparation. The author reviewed and approved the revised text and remains responsible for the final manuscript.

IV. Results

A. Runtime Decomposition

The primary finding is a two-process runtime coupled with a three-layer responsibility structure. The presentation process hosts the Gradio interface and handles browser interaction, audio capture, VAD, and incremental rendering. The FastAPI process owns request handling and service orchestration. Service modules isolate cloud LLM calls, local STT, and persistence, while configuration and Pydantic schemas provide supporting contracts. The processes communicate through HTTP rather than shared memory.
The resulting runtime decomposition and responsibility boundaries are summarized in Figure 1.
The apparent three-layer separation is not absolute. The Live Assistant directly imports the transcription service from the presentation process so that raw microphone PCM does not have to be serialized and transported through the backend. This is a deliberate optimization of the live path, but it weakens the otherwise clean process boundary and creates independent process-local model state. The architecture therefore implements separation where it produces the largest coordination benefit while violating the boundary where local data movement would otherwise become expensive.
The principal runtime findings are consolidated in Table 3.

B. Feature-to-Service Trace

The non-streaming feature paths follow a largely uniform sequence: resolve a session identifier, accept a typed request, call one service operation, attempt persistence, and return a typed response. The regularity of this pattern supports inspectability. It also creates a useful diagnostic invariant: if a feature follows the normal path, its principal business logic should be visible in one service call. The architecture documentation identifies transcription, summarization, correction, suggestion chat, model listing, session listing, and feedback as distinct API-level operations.
Table 4 traces each user-facing feature to its presentation input, backend boundary, and primary processing path.

C. Speech-Model Lifecycle and Resource Ownership

The local speech model is initialized lazily and guarded by double-checked locking. The first transcription call takes the initialization path; later calls reuse the process-local model. This pattern addresses concurrent construction within a process and keeps the import and model-loading cost off request paths that never use STT. The upload path writes decoded audio to a temporary file, whereas the live path passes raw PCM arrays directly to the transcription service after normalization and optional resampling.
The main architectural consequence occurs across the process boundary. The live path can load a separate model instance from the backend upload path because module-level state is not shared between OS processes. “Singleton” therefore means singleton within one process, not shared ownership at the deployment level. This distinction is important when reasoning about memory and scaling: adding an additional process can multiply model residency even though each process internally uses a singleton pattern.

D. Live Audio State Machine

The Live Assistant transforms continuous microphone events into semantic requests using a state machine. The documented configuration uses 30 ms VAD frames, a chunk-level speech rule requiring more than 30% speech-classified frames, a 700 ms silence threshold, and a 300 ms minimum utterance duration. Speech chunks are accumulated while the system is in the speaking state. Once sufficient silence is observed, the utterance is finalized, short utterances are discarded, local STT is invoked, and the recognized question is forwarded for streamed LLM generation.
The live processing sequence is illustrated in Figure 2.
This state machine is more than preprocessing. It is the semantic boundary that decides when a physical signal becomes a computational request. It reduces the number of model invocations compared with treating every microphone callback as a request, while introducing threshold-dependent risks. The evidence documents the values, but it does not show whether the values are optimal across speakers, microphones, noise conditions, or languages.

E. Streaming Integrity and Error Semantics

The server emits model output through SSE and JSON-encodes each chunk before placing it in the data field. This protects multiline model output from being interpreted as multiple SSE lines. The implementation therefore solves a concrete framing problem at the server boundary. However, the client-side consumer documented in the case primarily processes data lines and does not use the preceding event type to distinguish an in-band error from normal text. A stream failure can consequently be rendered as answer text rather than a distinct error state. The case therefore separates two concepts that are sometimes conflated: transport framing correctness and end-to-end failure semantics.
Table 5 summarizes the implementation-visible failure and maintainability risks identified through the code-level trace.

F. Persistence and Operational Resilience

Session records are written as JSON objects to object storage with session, action, and timestamp information encoded in the object key. The key design lets the history view reconstruct session summaries from object listings without retrieving every record. This is operationally simple, but writes are best effort: persistence errors are caught and suppressed so they do not block the primary request. The resulting availability choice is appropriate to a proof of concept but cannot be interpreted as an audit guarantee.
A lightweight watchdog manages the two processes, records process identifiers, exposes status and log commands, and checks process liveness periodically. This improves recovery from process crashes but does not establish distributed redundancy, automatic failover, capacity management, or comprehensive observability. The evidence supports “lightweight crash recovery,” not high availability.

G. Trace-Based Architectural Evaluation

Table 6 summarizes the evidence-guided architectural evaluation.

V. Discussion

A. Interpreting the Architectural Trade-offs

The findings indicate that the system is best understood as a set of negotiated boundaries rather than as a simple hierarchy. The two-process design improves separation between public presentation and backend orchestration, yet its process isolation interacts with the decision to keep live STT close to the microphone. The result is a boundary that is architecturally clean at the HTTP/API level but intentionally crossed for the live audio path. This is not inherently a defect; it is a context-dependent decision whose cost becomes visible only when resource ownership is examined across processes.
Similarly, the VAD mechanism demonstrates that real-time semantics are partly architectural. The system must decide when an utterance exists before it can invoke a speech model and then an LLM. A 700 ms silence threshold is therefore not merely a tuning constant; it participates in the request-generation policy. Its suitability cannot be inferred from its existence or from a generic range reported elsewhere. It requires workload-specific evaluation.
The streaming analysis produces a second important distinction. JSON framing can make an SSE transport robust against embedded newlines, but protocol correctness is not exhausted by framing. The client must also interpret event types consistently with the server. This suggests a general systems principle for AI streaming interfaces: reliability should be reviewed across the complete producer-consumer protocol contract, not at one endpoint in isolation.
Finally, persistence illustrates the difference between operational availability and evidence completeness. Swallowing storage errors protects the primary interaction, but it also creates a silent observability gap. In an interactive assistant, that may be acceptable for a prototype; in a system where transcripts constitute an audit record, the same design would need durable retry or acknowledgement semantics. The appropriate architecture therefore depends on the business meaning of the persisted artifact.

B. Case-Derived Propositions

Four propositions follow from the cross-boundary analysis. P1: placing high-rate microphone preprocessing close to the capture process can simplify transport, but process separation can duplicate local model resources. P2: real-time AI systems require an explicit semantic boundary that turns continuous input events into discrete model requests; endpointing is consequently an architectural concern. P3: streaming reliability is a two-sided protocol property: correct server framing is necessary but insufficient when client-side event semantics are incomplete. P4: best-effort persistence is an availability-oriented choice and should not be described as audit-grade persistence without additional delivery guarantees.
These propositions are deliberately case-derived rather than universal laws. Their scientific value is their testability. Each can be examined through controlled comparisons using alternative process topologies, endpoint thresholds, protocol consumers, and persistence mechanisms.

C. Implications for Information Systems Engineering

The case is an information-system problem because its value is produced by coordination among human interaction, local computation, remote AI services, state, and operational persistence. This aligns with the broader design-science view that information-systems research concerns artifacts intended to extend human and organizational capabilities [3]. The present study applies that perspective to an implemented system through architecture reconstruction and execution-trace analysis.
A second implication is methodological: architecture documentation should be treated as an executable hypothesis about system behavior. In this case, the high-level separation appears coherent until implementation traces expose exceptions such as process-local model state, client/server differences in streaming error semantics, and persistence that can fail without changing the primary response. For information-systems engineering, this suggests that architecture reviews should pair structural models with representative traces, explicit resource ownership, and negative-path analysis. Such a review can reveal risks before a system is evaluated solely by nominal feature demonstrations. It also creates a direct bridge from architectural reasoning to empirical evaluation: each identified boundary can be translated into a measurable test condition. This makes the architecture easier to audit, compare, and evolve without claiming that one implementation is universally optimal.
For practitioners, AI-system architecture should document not only components and data flows but also resource ownership and failure semantics. A component diagram can show that a speech model exists; trace evidence is needed to reveal whether multiple processes instantiate it independently. Likewise, an API specification can expose an SSE endpoint without proving that clients distinguish error events from normal output. Pairing structural architecture models with execution traces therefore makes reviews more auditable and provides direct inputs for empirical testing.

D. Evaluation Implications and Open Empirical Questions

The present analysis establishes architectural relationships and implementation-visible risks; the next research step is empirical validation of the most consequential boundaries. The evaluation roadmap therefore focuses on five measurable questions: speech quality under representative conditions; endpointing behavior and response latency; resource consumption under alternative process topologies; concurrent-user behavior; and persistence and streaming semantics under controlled failure injection. These measurements would test the propositions derived from the case without assuming in advance that one implementation is universally optimal.
Table 7 translates the identified architectural questions into an empirical evaluation roadmap.

E. Scope and Future Work

The study focuses on one implemented application and therefore treats transferability as a question for additional cases. The present contribution is architectural and trace-based; future work can extend the same analytical framework to controlled performance, usability, security, cost, and cross-architecture evaluations. Further studies can then test whether the trade-offs identified here recur in alternative implementations.

VI. Conclusion

I presented an evidence-guided architectural analysis of a real-time AI transcription assistant integrating local speech recognition, cloud LLM inference, voice activity detection, interactive state, streaming output, and session persistence. By tracing implementation behavior rather than relying solely on a high-level diagram, I identified how responsibility boundaries, process-local resources, semantic endpointing, protocol framing, and persistence semantics interact.
The results show that important quality attributes emerge from cross-boundary decisions. Process isolation improves responsibility separation but can duplicate process-local model state; endpointing converts continuous audio into discrete model requests; correct streaming framing does not by itself complete end-to-end error handling; and best-effort persistence favors uninterrupted interaction over guaranteed record delivery. These findings expose concrete architectural trade-offs that can be tested in subsequent comparative evaluations.
I present the implemented assistant as a concrete architectural case study. The contribution is the reconstruction of its runtime and responsibility boundaries, the trace-based identification of implementation-visible trade-offs, and a set of case-derived propositions that provide a direct basis for comparative evaluation. The study therefore contributes an architectural account that is both specific to the implemented artifact and useful for designing subsequent evaluations of real-time AI information systems.

Author Contributions

The author conducted the conceptualization, methodology, software and architecture analysis, investigation, visualization, and preparation and revision of the manuscript.

Funding

No external funding was received for this study.

Conflicts of Interest

No other competing interests are declared.

Human and Animal Subjects

No human-subject experiment, user study, or animal study was conducted as part of this research.

Disclosure of Generative AI

The authors declare that no generative artificial intelligence (GenAI) tools, large language models, or AI-assisted writing software were used.

Artifact and Demonstration Access

The implemented system and demonstration interface are available at https://transcribe.aiagentfolio.com/. The demonstration provides an operational view of the artifact analyzed in this study.

References

  1. Sculley, D.; et al. Hidden technical debt in machine learning systems. Proc. Adv. Neural Inf. Process. Syst. 2015, vol. 28, 2503–2511. [Google Scholar]
  2. Runeson, P.; Höst, M. Guidelines for conducting and reporting case study research in software engineering. Empir. Softw. Eng. 2009, vol. 14, 131–164. [Google Scholar] [CrossRef]
  3. Hevner, R.; March, S. T.; Park, J.; Ram, S. Design science in information systems research. MIS Q. 2004, vol. 28(no. 1), 75–105. [Google Scholar] [CrossRef]
  4. Washizaki, H.; et al. Software-engineering design patterns for machine learning applications. Computer 2022, vol. 55(no. 3), 30–39. [Google Scholar] [CrossRef]
  5. Amou Najafabadi, F.; Bogner, J.; Gerostathopoulos, I.; Lago, P. An analysis of MLOps architectures: A systematic mapping study. Proc. 18th Eur. Conf. Software Architecture, 2024; pp. 69–85. [Google Scholar] [CrossRef]
  6. Najafabadi, F. A.; Bogner, J.; Gerostathopoulos, I.; Lago, P. An architectural perspective on MLOps: Structures, processes, tools, and stakeholders. Inf. Softw. Technol. 2026, vol. 193, 108029. [Google Scholar] [CrossRef]
  7. Radford, et al. Robust speech recognition via large-scale weak supervision. Proc. 40th Int. Conf. Mach. Learn. 2023, vol. 202, 28492–28518. [Google Scholar]
  8. Sohn, J.; Kim, N. S.; Sung, W. A statistical model-based voice activity detection. IEEE Signal Process. Lett. 1999, vol. 6(no. 1), 1–3. [Google Scholar] [CrossRef]
  9. WHATWG, “Server-sent events,” HTML Living Standard. Available online: https://html.spec.whatwg.org/dev/server-sent-events.html.
  10. Amazon Web Services, “Converse,” Amazon Bedrock API Reference. Available online: https://docs.aws.amazon.com/bedrock/latest/APIReference/API_runtime_Converse.html.
  11. Amazon Web Services, “ConverseStream,” Amazon Bedrock API Reference. Available online: https://docs.aws.amazon.com/bedrock/latest/APIReference/API_runtime_ConverseStream.html.
  12. Gradio, “Streaming inputs,” Gradio Documentation. Available online: https://gradio.app/guides/streaming-inputs.
  13. FastAPI, “Server-sent events,” FastAPI Documentation. Available online: https://fastapi.tiangolo.com/tutorial/server-sent-events/.
  14. Amazon Web Services, “Machine Learning Lens,” AWS Well-Architected Framework. Available online: https://docs.aws.amazon.com/wellarchitected/latest/machine-learning-lens/.
Figure 1. Consolidated runtime architecture and responsibility boundaries.
Figure 1. Consolidated runtime architecture and responsibility boundaries.
Preprints 244358 g001
Figure 2. Live Assistant audio-state and streaming-response pipeline.
Figure 2. Live Assistant audio-state and streaming-response pipeline.
Preprints 244358 g002
Table 1. Evidence sources and analytical role.
Table 1. Evidence sources and analytical role.
Artifact / evidence Role in analysis Primary questions
Architecture and implementation framework Defines intended runtime and logical structure What components and layers are present?
Code-level walkthrough Explains imports, function behavior, state, errors, and defects How do boundaries behave in implementation?
Architecture-and-execution specification Connects modules to endpoints and representative workflows How does data move across runtime boundaries?
External literature and technical specifications Provides established architectural context Which observations are consistent with prior knowledge?
Table 2. Research questions and trace-based analysis.
Table 2. Research questions and trace-based analysis.
RQ Evidence traced Analytical output
RQ1 Processes, modules, endpoint contracts, dependencies Runtime/layer model and feature-to-service map
RQ2 Model lifecycle, VAD state, HTTP/SSE transport, persistence Decision and trade-off analysis
RQ3 Exception paths, stream events, validation, storage failures, version coupling Failure inventory and testable propositions
Table 3. Runtime and responsibility findings.
Table 3. Runtime and responsibility findings.
Observed element Direct evidence Architectural interpretation
Runtime Two independent OS processes with separate entry points Process separation isolates presentation from backend orchestration
Logical layers Routes -> services -> infrastructure/configuration Responsibilities are inspectable and changes can be localized
Cross-boundary exception UI directly imports local STT service for live audio Locality improves live-path transport but duplicates process-local model state
Request contract Pydantic request/response models at API boundary Structural validation is strong; semantic validation is incomplete in some fields
Table 4. FEATURE-TO-SERVICE TRACE.
Table 4. FEATURE-TO-SERVICE TRACE.
Feature Presentation input Backend boundary Primary processing
Transcribe Audio upload or existing text POST /transcribe Local STT or text passthrough
Summarise Transcript + options POST /summarise Bedrock LLM request
Correct / Format Transcript + format POST /correct Bedrock LLM request
Suggest Message + transcript + history POST /suggest Transcript-context chat + Bedrock
Live Assistant Streaming microphone or typed question POST /live/ask via SSE Local STT + streamed Bedrock reply
History Session view GET /sessions Object-storage listing
Table 5. Implementation-visible failure and maintainability risks.
Table 5. Implementation-visible failure and maintainability risks.
Failure / risk Location Observed behavior Consequence
Process-local model duplication UI/backend process boundary Each process can initialize its own Whisper model Memory growth when both paths are active
Semantic validation gap API schema boundary Some fields are typed as free-form strings Unexpected values reach downstream prompts
In-band stream error SSE client/server boundary Server emits error event; client mainly consumes data lines Failure may appear as ordinary reply text
Best-effort persistence Object-storage boundary Storage ClientError is swallowed Primary request succeeds without guaranteed record
Session-list truncation Storage listing logic Limit is applied before global time sorting Returned records are not guaranteed to be most recent
Table 6. Evidence-Guided Architecture Evaluation.
Table 6. Evidence-Guided Architecture Evaluation.
Criterion Evidence strength What the evidence supports What remains unverified
Responsibility separation Strong Distinct processes, routes, services, schemas, and infrastructure Effect of future refactoring on coupling
Contract consistency Moderate Typed API structures and uniform handler pattern Semantic constraints, negative tests, malformed histories
Resource ownership Moderate Process-local lazy STT lifecycle is explicit Actual memory/CPU impact under concurrent load
Real-time state control Strong Explicit VAD-to-utterance state machine False endpoint and response-delay rates
Streaming integrity Strong for framing JSON-framed SSE preserves multiline chunks End-to-end error/reconnect semantics
Persistence/resilience Moderate Object-storage logging and watchdog are explicit Durability, recovery, retention, and operational SLOs
Table 7. Empirical evaluation roadmap.
Table 7. Empirical evaluation roadmap.
Evaluation question Minimum measurement Why it matters
Is the local STT configuration adequate? WER/CER by language, accent, noise Separates architectural suitability from model assumptions
Is 700 ms endpointing justified? False/missed endpoints and added delay Tests the interaction-state policy
Does the process split help responsiveness? TTFT, end-to-end latency, queueing Tests the claimed rationale for locality
Is duplicated model residency acceptable? Memory and compute under representative load Quantifies resource cost of process isolation
Does the system behave under concurrency? Throughput, queueing, error rate, recovery Tests operational scalability
Is persistence sufficiently durable? Injected-fault loss rate and recovery time Tests availability versus audit trade-off
Is SSE behavior end-to-end correct? Multiline, error-event, reconnect and termination tests Tests producer-consumer protocol semantics
Can the system move beyond prototype use? Authentication, retention, access-control and privacy assessment Tests security and governance assumptions
Disclaimer/Publisher’s Note: The statements, opinions and data contained in all publications are solely those of the individual author(s) and contributor(s) and not of MDPI and/or the editor(s). MDPI and/or the editor(s) disclaim responsibility for any injury to people or property resulting from any ideas, methods, instructions or products referred to in the content.
Copyright: This open access article is published under a Creative Commons CC BY 4.0 license, which permit the free download, distribution, and reuse, provided that the author and preprint are cited in any reuse.