Terms of Service — Functory

These Terms of Service (“Terms”) govern your access to and use of Functory, a platform to publish, discover, and run executable software functions (“Functions”). By creating an account, publishing a Function, or running one, you agree to these Terms.

• Functory: the site, APIs, and services operated by TODO: legal entity (“we”, “us”).
• Creator: a user who publishes a Function (code, metadata, schemas, pricing).
• Runner: a user who executes a Function via the UI, API, or SDK.
• Tokens: Functory-internal usage credits (billing units), not currency or securities.
• Execution: invocation of a Function, including SSE logs, artifacts, and outputs.
• Artifacts: files consumed/produced during Executions, exchanged via presigned links (e.g., S3/MinIO).
• Marketplace: the public catalog of Functions available for discovery and execution.

Alpha notice. Functory is currently in Alpha. The service is provided “as is,” may contain bugs, and may be interrupted. Do not use it for safety-critical or highly sensitive workloads.

• You must have legal capacity to contract. Business and professional use is recommended.
• You’re responsible for your account information, credential security, and all actions under your account.
• Usernames may be subject to uniqueness rules and limited update frequency.
• If you sign up on behalf of an organization, you represent you have authority to bind that organization.
• We may refuse, suspend, or reclaim usernames that impersonate, infringe, or mislead.

Creators

• You represent you own or have rights to the code, data, and materials in your Functions.
• You define monetization (e.g., fixed tokens per call, tokens per compute-second, creator/platform split).
• You agree that certain metadata (title, tags, description, run counts, rating) may be publicly displayed.
• Your Functions must not include malware, unauthorized mining, spam, or rights-infringing content.

Runners

• You are responsible for the inputs you supply and how you use outputs.
• Creators may impose execution licenses or additional use restrictions.
• Usage, rate, or resource limits may apply (e.g., CPU/RAM/time caps).

• Published versions are immutable (code and metadata are frozen). Fixes require a new version.
• Published pricing is reduce-only for that version (no retroactive increases).
• Visibility can be private (restricted access) or public (catalog). Public Functions must be documented and runnable without undisclosed internal configuration.
• We may de-list or hide Functions that violate these Terms or applicable law.

• Tokens are prepaid credits used to execute Functions. They have no monetary value outside Functory, earn no interest, and are not financial instruments.
• An Execution may combine a fixed price (per call) and a variable price (per compute-second).
• Consumption may be deducted progressively during Execution (startup, compute time, artifact ops).
• Fiat payments are handled by third-party providers (e.g., payment processors). Taxes may apply.
• Refunds: unless legally required, consumed Tokens are non-refundable. If an incident is attributable to Functory, we may grant goodwill credits at our discretion.
• In case of chargebacks, fraud, or unpaid invoices, we may suspend access and invalidate Tokens.

• The creator/platform split applies to each Execution (e.g., creator_share_pct/platform_share_pct). Amounts accrue and are paid out on a reasonable schedule.
• We may require KYC/AML information and tax documentation before payouts.
• You are responsible for your tax obligations. We may collect or remit taxes where required by law.
• We may withhold amounts in case of disputes, suspected fraud, or user claims.

Prohibited, without limitation:

• Malware, botnets, unauthorized crypto-mining, DDoS, port scans, spam, fraud, unauthorized access.
• Illegal content, defamation, hate, explicit sexual content, exploitation of minors.
• Processing personal data without a lawful basis; IP infringement (copyright, trademarks, trade secrets).
• Functions to bypass security, scrape at scale against robots.txt, or violate third-party terms.
• Use in safety-critical contexts without written approval (healthcare, aviation, etc.).

• Artifacts are exchanged via presigned links (e.g., S3/MinIO). Handle links carefully and expire/revoke them when no longer needed.
• Logs (SSE and final) and execution metadata (duration, status, errors) may be stored for debugging, billing, and service improvement.
• You are responsible for encrypting and pseudonymizing sensitive data before submission.
• We may set quotas, retention windows, and perform purges of inactive artifacts with reasonable notice where feasible.

• You retain rights in your Functions. By publishing, you grant us a worldwide, non-exclusive, transferable, sublicensable license limited to operating the platform: host, store, catalog, and execute your Function at Runners’ request.
• For each Runner, you grant an execution license limited to permitted uses (public/private settings, pricing, and restrictions you configure).
• Functory’s trademarks, logos, and UI remain our property. No confusing or unauthorized use.
• Feedback: you grant us a royalty-free license to use suggestions to improve the service.

• Functions may include open-source dependencies. You must comply with their licenses (e.g., MIT, Apache-2.0, GPL family).
• Some capabilities (payments, storage, compute, logging, email) rely on third-party providers. Their terms and privacy policies apply as well.

• We process personal data for authentication, billing/tokens, fraud prevention, support, and improvement. See our separate Privacy Policy.
• We do not use your private code or private execution data to train models without consent. Public Functions may feed aggregated signals (e.g., trends) for discovery/quality.
• If you process end-user personal data via a Function, you are the controller for that processing and must have a lawful basis. A Data Processing Addendum is available on request.

• We apply reasonable measures (execution isolation, presigned link controls, quotas, access management). No system is perfectly secure.
• Report suspected vulnerabilities to security@functory.dev and follow responsible disclosure.
• We may suspend a Function that threatens platform security or integrity.

• We may change the service (UI, APIs, SDKs, pricing, limits) and these Terms. For material changes, we’ll provide reasonable notice where feasible.
• Continued use after the effective date constitutes acceptance of the updated Terms.

• You may stop using the service at any time. Some records may persist for compliance, billing, or fraud prevention.
• We may suspend/terminate for violations, security risks, fraud, non-payment, or lawful requests.
• Upon termination, access is revoked; short retrieval windows may be offered at our discretion (no guarantee).

• Alpha — “AS IS”. No warranty of fitness, availability, or error-free operation. Objectives and roadmaps are not contractual commitments.
• Limitation. To the maximum extent permitted by law, our aggregate liability is limited to the greater of (i) €100 and (ii) the platform fees you paid in the 3 months preceding the event.Consumer rights under mandatory law are not limited.
• Indemnification. You will defend and hold us harmless from claims arising from your code, data, Functions, use, or infringement of third-party rights or law.

Consumer law non-waiver. If you are a consumer and mandatory laws in your country grant you additional rights, nothing here limits those rights.

• You must comply with applicable export control and sanctions laws (e.g., EU, UK, U.S.). You warrant you are not located in, or a resident of, a sanctioned country or on a restricted list.
• You will not use Functory for prohibited end uses (e.g., weapons, WMD, or other restricted programs).

• Unless a different governing law is required by mandatory local law, these Terms are governed by the laws of France (excluding conflict-of-law rules). Venue: Lille Métropole courts.
• EEA/UK consumers: you may bring claims in your local courts and under your local mandatory law.
• Arbitration (where permitted): we may offer arbitration as a faster route; details provided on request. This clause does not apply where prohibited by law.

• Entire agreement. These Terms constitute the whole agreement and supersede prior agreements.
• Severability. If a clause is unenforceable, the rest remains in effect.
• Assignment. You may not assign these Terms without our written consent. We may assign in connection with a merger, acquisition, or asset sale.
• Force majeure. No liability for events beyond reasonable control.
• Notices. We may notify you by email, admin panel, or in-product message.
• No reverse engineering. You won’t attempt to access the platform’s source code or circumvent technical protections except where permitted by law.

Legal inquiries, content notices (including DMCA-like takedowns), or questions about these Terms:
Email: legal@functory.dev
Security: security@functory.dev
Privacy/DPO: privacy@functory.dev
Mailing address: TODO: Legal entity & full address

For copyright complaints, include: the Function URL, a precise description of the content, your contact details, and the legal basis for your request.